HttpUtilities.java

  1. /*
  2.  * GovWay - A customizable API Gateway 
  3.  * https://govway.org
  4.  * 
  5.  * Copyright (c) 2005-2025 Link.it srl (https://link.it). 
  6.  * 
  7.  * This program is free software: you can redistribute it and/or modify
  8.  * it under the terms of the GNU General Public License version 3, as published by
  9.  * the Free Software Foundation.
  10.  *
  11.  * This program is distributed in the hope that it will be useful,
  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.  * GNU General Public License for more details.
  15.  *
  16.  * You should have received a copy of the GNU General Public License
  17.  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18.  *
  19.  */


  22. package org.openspcoop2.utils.transport.http;

  24. import java.io.ByteArrayOutputStream;
  25. import java.io.File;
  26. import java.io.FileInputStream;
  27. import java.io.InputStream;
  28. import java.io.OutputStream;
  29. import java.lang.reflect.Field;
  30. import java.net.HttpURLConnection;
  31. import java.net.InetSocketAddress;
  32. import java.net.Proxy;
  33. import java.net.URL;
  34. import java.net.URLConnection;
  35. import java.security.Key;
  36. import java.security.KeyStore;
  37. import java.security.Provider;
  38. import java.security.cert.CertStore;
  39. import java.util.ArrayList;
  40. import java.util.Enumeration;
  41. import java.util.HashMap;
  42. import java.util.Iterator;
  43. import java.util.List;
  44. import java.util.Map;

  46. import javax.net.ssl.CertPathTrustManagerParameters;
  47. import javax.net.ssl.HttpsURLConnection;
  48. import javax.net.ssl.KeyManager;
  49. import javax.net.ssl.KeyManagerFactory;
  50. import javax.net.ssl.SSLContext;
  51. import javax.net.ssl.TrustManager;
  52. import javax.net.ssl.TrustManagerFactory;
  53. import javax.net.ssl.X509KeyManager;
  54. import javax.servlet.http.HttpServletRequest;
  55. import javax.servlet.http.HttpServletResponse;

  57. import org.apache.commons.codec.digest.DigestUtils;
  58. import org.apache.commons.lang.StringUtils;
  59. import org.openspcoop2.utils.CopyStream;
  60. import org.openspcoop2.utils.LoggerWrapperFactory;
  61. import org.openspcoop2.utils.Utilities;
  62. import org.openspcoop2.utils.UtilsException;
  63. import org.openspcoop2.utils.certificate.KeystoreType;
  64. import org.openspcoop2.utils.certificate.KeystoreUtils;
  65. import org.openspcoop2.utils.certificate.hsm.HSMManager;
  66. import org.openspcoop2.utils.digest.DigestEncoding;
  67. import org.openspcoop2.utils.io.Base64Utilities;
  68. import org.openspcoop2.utils.mime.MimeTypes;
  69. import org.openspcoop2.utils.random.RandomGenerator;
  70. import org.openspcoop2.utils.regexp.RegExpUtilities;
  71. import org.openspcoop2.utils.resources.FileSystemUtilities;
  72. import org.openspcoop2.utils.resources.Loader;
  73. import org.openspcoop2.utils.transport.TransportUtils;
  74. import org.slf4j.Logger;


  77. /**
  78.  * Classe che contiene utility per accedere a risorse http 
  79.  *
  80.  * @author Poli Andrea (apoli@link.it)
  81.  * @author $Author$
  82.  * @version $Rev$, $Date$
  83.  */
  84. public class HttpUtilities {
  85.     
  86.     private HttpUtilities() {}

  88.     /**
  89.      * Si occupa di effettuare la connessione verso l'indirizzo specificato dal<var>path</var>.
  90.      * 
  91.      *
  92.      * @param path url del file xml contenente la definizione di un servizio.
  93.      * @return i byte del file xml situato all'indirizzo <var>path</var>.
  94.      * 
  95.      */
  96.     /** TIMEOUT_CONNECTION (2 minuti) */
  97.     public static final int HTTP_CONNECTION_TIMEOUT = 10000; 
  98.     /** TIMEOUT_READ (2 minuti) */
  99.     public static final int HTTP_READ_CONNECTION_TIMEOUT = 120000; 

  101.     
  102.     public static List<String> getClientAddressHeaders() {
  103.         // X-Forwarded-For: A de facto standard for identifying the originating IP address of a client connecting to a web server through an HTTP proxy or load balancer
  104.         // Forwarded: Disclose original information of a client connecting to a web server through an HTTP proxy.'
  105.         List<String> possibiliHeaders = new ArrayList<>();
  106.         possibiliHeaders.add("X-Forwarded-For");
  107.         possibiliHeaders.add("Forwarded-For"); // senza la 'X-' nel caso l'header venga fatto rendere uno standard
  108.         possibiliHeaders.add("X-Forwarded");
  109.         possibiliHeaders.add("Forwarded");
  110.         possibiliHeaders.add("X-Client-IP");
  111.         possibiliHeaders.add("Client-IP");
  112.         possibiliHeaders.add("X-Cluster-Client-IP");
  113.         possibiliHeaders.add("Cluster-Client-IP");
  114.         return possibiliHeaders;
  115.     }
  116.     public static String getClientAddress(HttpServletRequest request) throws UtilsException{
  117.         try{
  118.             return getClientAddress(getClientAddressHeaders(), request);
  119.         }catch(Exception e){
  120.             throw new UtilsException(e.getMessage(),e);
  121.         }
  122.     }
  123.     public static String getClientAddressFirstValue(HttpServletRequest request) throws UtilsException{
  124.         return getClientAddress(request);
  125.     }
  126.     private static String getClientAddress(List<String> headers, HttpServletRequest request) throws UtilsException{
  127.         if(!headers.isEmpty()){
  128.             for (String header : headers) {
  129.                 List<String> l = TransportUtils.getHeaderValues(request,header);
  130.                 if(l!=null && !l.isEmpty()) {
  131.                     return l.get(0);
  132.                 }
  133.             }
  134.         }
  135.         return null;
  136.     }
  137.     
  138.     @Deprecated
  139.     public static String getClientAddress(Map<String, String> transportProperties) throws UtilsException{
  140.         return getClientAddress(getClientAddressHeaders(), TransportUtils.convertToMapListValues(transportProperties));
  141.     }
  142.     public static String getClientAddressFirstValue(Map<String, List<String>> headers) throws UtilsException{
  143.         return getClientAddress(getClientAddressHeaders(), headers);
  144.     }
  145.     private static String getClientAddress(List<String> headers, Map<String, List<String>> transportProperties) {
  146.         if(!headers.isEmpty()){
  147.             for (String header : headers) {
  148.                 List<String> l = TransportUtils.getRawObject(transportProperties,header);
  149.                 if(l!=null && !l.isEmpty()) {
  150.                     return l.get(0);
  151.                 }
  152.             }
  153.         }
  154.         return null;
  155.     }
  156.     
  157.     
  158.     public static String getHttpReason(int status) {
  159.     
  160.         if(status==100) {
  161.             return "Continue"; // HTTP/1.1 - RFC 2616  [RFC7231, Section 6.2.1]
  162.         }
  163.         else if(status==101) {
  164.             return "Switching Protocols"; // HTTP/1.1 - RFC 2616  [RFC7231, Section 6.2.2]
  165.         }
  166.         else if(status==102) {
  167.             return "Processing"; // WebDAV - RFC 2518  [RFC2518]
  168.         }
  169.         // 103-199  Unassigned  
  170.         
  171.                 
  172.         
  173.         else if(status==200) {
  174.             return "OK"; // HTTP/1.0 - RFC 1945  [RFC7231, Section 6.3.1]
  175.         }
  176.         else if(status==201) {
  177.             return "Created"; // HTTP/1.0 - RFC 1945  [RFC7231, Section 6.3.2]
  178.         }
  179.         else if(status==202) {
  180.             return "Accepted"; // HTTP/1.0 - RFC 1945  [RFC7231, Section 6.3.3]
  181.         }
  182.         else if(status==203) {
  183.             return "Non-Authoritative Information"; // HTTP/1.1 - RFC 2616  [RFC7231, Section 6.3.4]
  184.         }
  185.         else if(status==204) {
  186.             return "No Content"; // HTTP/1.0 - RFC 1945  [RFC7231, Section 6.3.5]
  187.         }
  188.         else if(status==205) {
  189.             return "Reset Content"; // HTTP/1.1 - RFC 2616  [RFC7231, Section 6.3.6]
  190.         }
  191.         else if(status==206) {
  192.             return "Partial Content"; // HTTP/1.1 - RFC 2616  [RFC7233, Section 4.1]
  193.         }
  194.         else if(status==207) {
  195.             return "Multi-Status"; // (WebDAV - RFC 2518)  [RFC4918] or 207 Partial Update OK (HTTP/1.1 - draft-ietf-http-v11-spec-rev-01?)
  196.         }
  197.         else if(status==208) {
  198.             return "Already Reported"; // WebDAV - RFC 2518  [RFC5842]
  199.         }
  200.         // 209-225  Unassigned  
  201.         else if(status==226) {
  202.             return "IM Used"; // [RFC3229]
  203.         }
  204.         // 227-299  Unassigned  
  205.         
  206.         
  207.         else if(status==300) {
  208.             return "Multiple Choices"; // HTTP/1.1 - RFC 2616  [RFC7231, Section 6.4.1]
  209.         }
  210.         else if(status==301) {
  211.             return "Moved Permanently"; // HTTP/1.0 - RFC 1945  [RFC7231, Section 6.4.2]
  212.         }
  213.         else if(status==302) {
  214.             return "Found"; // HTTP/1.0 - RFC 1945  [RFC7231, Section 6.4.3]
  215.         }
  216.         else if(status==303) {
  217.             return "See Other"; // HTTP/1.1 - RFC 2616  [RFC7231, Section 6.4.4]
  218.         }       
  219.         else if(status==304) {
  220.             return "Not Modified"; // HTTP/1.0 - RFC 1945  [RFC7232, Section 4.1]
  221.         }
  222.         else if(status==305) {
  223.             return "Use Proxy"; // HTTP/1.1 - RFC 2616  [RFC7231, Section 6.4.5]
  224.         }
  225.         else if(status==306) {
  226.             return "Switch Proxy"; // (Unused)  [RFC7231, Section 6.4.6]
  227.         }
  228.         else if(status==307) {
  229.             return "Temporary Redirect"; // HTTP/1.1 - RFC 2616  [RFC7231, Section 6.4.7]
  230.         }
  231.         else if(status==308) {
  232.             return "Permanent Redirect"; // [RFC7538]
  233.         }
  234.         // 309-399  Unassigned  
  235.         

  237.         else if(status==400) {
  238.             return "Bad Request"; // HTTP/1.1 - RFC 2616  [RFC7231, Section 6.5.1]
  239.         }
  240.         else if(status==401) {
  241.             return "Unauthorized"; // HTTP/1.0 - RFC 1945  [RFC7235, Section 3.1]
  242.         }
  243.         else if(status==402) {
  244.             return "Payment Required"; // HTTP/1.1 - RFC 2616  [RFC7231, Section 6.5.2]
  245.         }
  246.         else if(status==403) {
  247.             return "Forbidden"; // HTTP/1.0 - RFC 1945  [RFC7231, Section 6.5.3]
  248.         }
  249.         else if(status==404) {
  250.             return "Not Found"; // HTTP/1.0 - RFC 1945  [RFC7231, Section 6.5.4]
  251.         }
  252.         else if(status==405) {
  253.             return "Method Not Allowed"; // HTTP/1.1 - RFC 2616  [RFC7231, Section 6.5.5]
  254.         }
  255.         else if(status==406) {
  256.             return "Not Acceptable"; // HTTP/1.1 - RFC 2616  [RFC7231, Section 6.5.6]
  257.         }
  258.         else if(status==407) {
  259.             return "Proxy Authentication Required"; // HTTP/1.1 - RFC 2616  [RFC7235, Section 3.2]
  260.         }
  261.         else if(status==408) {
  262.             return "Request Timeout"; // [RFC7231, Section 6.5.7]
  263.         }
  264.         else if(status==409) {
  265.             return "Conflict"; // HTTP/1.1 - RFC 2616  [RFC7231, Section 6.5.8]
  266.         }
  267.         else if(status==410) {
  268.             return "Gone"; // HTTP/1.1 - RFC 2616  [RFC7231, Section 6.5.9]
  269.         }
  270.         else if(status==411) {
  271.             return "Length Required"; // HTTP/1.1 - RFC 2616  [RFC7231, Section 6.5.10]
  272.         }
  273.         else if(status==412) {
  274.             return "Precondition Failed"; // HTTP/1.1 - RFC 2616  [RFC7232, Section 4.2][RFC8144, Section 3.2]
  275.         }
  276.         else if(status==413) {
  277.             return "Payload Too Large"; // HTTP/1.1 - RFC 2616  [RFC7231, Section 6.5.11]
  278.         }
  279.         else if(status==414) {
  280.             return "URI Too Long"; // HTTP/1.1 - RFC 2616  [RFC7231, Section 6.5.12]
  281.         }
  282.         else if(status==415) {
  283.             return "Unsupported Media Type"; // HTTP/1.1 - RFC 2616  [RFC7231, Section 6.5.13][RFC7694, Section 3]
  284.         }
  285.         else if(status==416) {
  286.             return "Range Not Satisfiable"; // HTTP/1.1 - RFC 2616  [RFC7233, Section 4.4]
  287.         }
  288.         else if(status==417) {
  289.             return "Expectation Failed"; // HTTP/1.1 - RFC 2616  [RFC7231, Section 6.5.14]
  290.         }
  291.         // 418 Unassigned
  292.         else if(status==419) {
  293.             return "Authentication Timeout"; // HTTP/1.1 - RFC 2616
  294.         }
  295.         // 420 Unassigned
  296.         else if(status==421) {
  297.             return "Misdirected Request"; // [RFC7540, Section 9.1.2]
  298.         }
  299.         else if(status==422) {
  300.             return "Unprocessable Entity"; // WebDAV - RFC 2518  [RFC4918]
  301.         }
  302.         else if(status==423) {
  303.             return "Locked"; // (WebDAV - RFC 2518) [RFC4918]
  304.         }
  305.         else if(status==424) {
  306.             return "Failed Dependency"; // WebDAV - RFC 2518 [RFC4918]
  307.         }
  308.         // 425 Unassigned
  309.         else if(status==426) {
  310.             return "Upgrade Required"; // [RFC7231, Section 6.5.15]
  311.         }
  312.         // 427 Unassigned
  313.         else if(status==428) {
  314.             return "Precondition Required"; // [RFC6585]
  315.         }
  316.         else if(status==429) {
  317.             return "Too Many Requests"; // [RFC6585]
  318.         }
  319.         // 430 Unassigned
  320.         else if(status==431) {
  321.             return "Request Header Fields Too Large"; // [RFC6585]
  322.         }
  323.         // 432-450  Unassigned
  324.         else if(status==451) {
  325.             return "Unavailable For Legal Reasons"; // [RFC7725]
  326.         }
  327.         // 452-499  Unassigned  
  328.         

  330.         else if(status==500) {
  331.             return "Internal Server Error"; // HTTP/1.0 - RFC 1945  [RFC7231, Section 6.6.1]
  332.         }
  333.         else if(status==501) {
  334.             return "Not Implemented"; // HTTP/1.0 - RFC 1945  [RFC7231, Section 6.6.2]
  335.         }
  336.         else if(status==502) {
  337.             return "Bad Gateway"; // HTTP/1.0 - RFC 1945  [RFC7231, Section 6.6.3]
  338.         }
  339.         else if(status==503) {
  340.             return "Service Unavailable"; // HTTP/1.0 - RFC 1945  [RFC7231, Section 6.6.4]
  341.         }
  342.         else if(status==504) {
  343.             return "Gateway Timeout"; // HTTP/1.1 - RFC 2616  [RFC7231, Section 6.6.5]
  344.         }
  345.         else if(status==505) {
  346.             return "HTTP Version Not Supported"; // HTTP/1.1 - RFC 2616  [RFC7231, Section 6.6.6]
  347.         }
  348.         else if(status==506) {
  349.             return "Variant Also Negotiates"; // [RFC2295]
  350.         }
  351.         else if(status==507) {
  352.             return "Insufficient Storage"; // WebDAV - RFC 2518  [RFC4918]
  353.         }
  354.         else if(status==508) {
  355.             return "Loop Detected"; // [RFC5842]
  356.         }
  357.         else if(status==509) {
  358.             return "Bandwidth Limit Exceeded"; // [Apache]
  359.         }
  360.         else if(status==510) {
  361.             return "Not Extended"; // [RFC2774]
  362.         }
  363.         else if(status==511) {
  364.             return "Network Authentication Required"; // [RFC6585]
  365.         }
  366.         // 512-599  Unassigned  

  368.         return null;
  369.     }
  370.     
  371.     
  372.     
  373.     public static final String HEADER_X_DOWNLOAD = "application/x-download";
  374.     public static final String HEADER_CONTENT_DISPOSITION = "Content-Disposition";
  375.     public static final String HEADER_ATTACH_FILE = "attachment; filename=";
  376.     
  377.     public static void setOutputFile(HttpServletResponse response, boolean noCache, String fileName) throws UtilsException{
  378.         
  379.         if(fileName==null) {
  380.             throw new UtilsException("Param filename is null");
  381.         }
  382.         
  383.         // setto content-type e header per gestire il download lato client
  384.         String mimeType = null;
  385.         if(fileName.contains(".")){
  386.             String ext = null;
  387.             try{
  388.                 ext = fileName.substring(fileName.lastIndexOf(".")+1,fileName.length());
  389.             }catch(Exception e){
  390.                 // ext non disponibile
  391.             }
  392.             MimeTypes mimeTypes = MimeTypes.getInstance();
  393.             if(ext!=null && mimeTypes.existsExtension(ext)){
  394.                 mimeType = mimeTypes.getMimeType(ext);
  395.                 /**System.out.println("CUSTOM ["+mimeType+"]");*/       
  396.             }
  397.             else{
  398.                 mimeType = HttpConstants.CONTENT_TYPE_X_DOWNLOAD;
  399.             }
  400.         }
  401.         else{
  402.             mimeType = HttpConstants.CONTENT_TYPE_X_DOWNLOAD;
  403.         }
  404.         
  405.         setOutputFile(response, noCache, fileName, mimeType);
  406.     }
  407.     
  408.     public static void setOutputFile(HttpServletResponse response, boolean noCache, String fileName, String mimeType) throws UtilsException{
  409.                 
  410.         if(response==null) {
  411.             throw new UtilsException("Param response is null");
  412.         }
  413.         
  414.         if(mimeType!=null){
  415.             response.setContentType(mimeType);
  416.         }

  418.         response.setHeader(HttpConstants.CONTENT_DISPOSITION, (new StringBuilder()).append(HttpConstants.CONTENT_DISPOSITION_ATTACH_FILE_PREFIX+"\"").append(fileName).append("\"").toString());
  419.         
  420.         // no cache
  421.         if(noCache){
  422.             setNoCache(response);
  423.         }
  424.         
  425.     }
  426.     
  427.     
  428.     
  429.     public static void setNoCache(HttpServletResponse response) {
  430.         response.setHeader(HttpConstants.CACHE_STATUS_HTTP_1_1, HttpConstants.CACHE_STATUS_HTTP_1_1_DISABLE_CACHE); // HTTP 1.1.
  431.         response.setHeader(HttpConstants.CACHE_STATUS_HTTP_1_0, HttpConstants.CACHE_STATUS_HTTP_1_0_DISABLE_CACHE); // HTTP 1.0.
  432.         response.setDateHeader(HttpConstants.CACHE_STATUS_PROXY_EXPIRES, HttpConstants.CACHE_STATUS_PROXY_EXPIRES_DISABLE_CACHE); // Proxies.
  433.         response.setHeader(HttpConstants.CACHE_STATUS_VARY, HttpConstants.CACHE_STATUS_VARY_UNCACHABLE);
  434.     }
  435.     
  436.     
  437.     @Deprecated
  438.     public static boolean isNoCache(Map<String, String> headers) throws UtilsException{
  439.         return isDirectiveNoCache(TransportUtils.convertToMapListValues(headers));
  440.     }
  441.     public static boolean isDirectiveNoCache(Map<String, List<String>> headers) throws UtilsException{
  442.         List<String> l = getCacheControlDirectives(headers);
  443.         if(l.isEmpty()) {
  444.             l = getPragmaDirectives(headers);
  445.         }
  446.         if(l.isEmpty()) {
  447.             return false;
  448.         }
  449.         else {
  450.             return l.contains(HttpConstants.CACHE_STATUS_DIRECTIVE_NO_CACHE);
  451.         }
  452.     }
  453.     
  454.     @Deprecated
  455.     public static boolean isNoStore(Map<String, String> headers) throws UtilsException{
  456.         return isDirectiveNoStore(TransportUtils.convertToMapListValues(headers));
  457.     }
  458.     public static boolean isDirectiveNoStore(Map<String, List<String>> headers) throws UtilsException{
  459.         List<String> l = getCacheControlDirectives(headers);
  460.         if(l.isEmpty()) {
  461.             l = getPragmaDirectives(headers);
  462.             if(l.isEmpty()) {
  463.                 return false;
  464.             }else{
  465.                 return l.contains(HttpConstants.CACHE_STATUS_DIRECTIVE_NO_CACHE); // no cache in pragma vale anche per nostore.
  466.             }
  467.         }
  468.         else {
  469.             return l.contains(HttpConstants.CACHE_STATUS_DIRECTIVE_NO_STORE);
  470.         }
  471.     }
  472.     
  473.     @Deprecated
  474.     public static Integer getCacheMaxAge(Map<String, String> headers) {
  475.         return getDirectiveCacheMaxAge(TransportUtils.convertToMapListValues(headers));
  476.     }
  477.     public static Integer getDirectiveCacheMaxAge(Map<String, List<String>> headers) {
  478.         List<String> l = getCacheControlDirectives(headers);
  479.         if(l.isEmpty()) {
  480.             return null;
  481.         }
  482.         else {
  483.             for (String direttiva : l) {
  484.                 if(direttiva!=null && direttiva.startsWith(HttpConstants.CACHE_STATUS_DIRECTIVE_MAX_AGE+"=") && !direttiva.endsWith("=")) {
  485.                     try {
  486.                         String age = direttiva.substring((HttpConstants.CACHE_STATUS_DIRECTIVE_MAX_AGE+"=").length(), direttiva.length());
  487.                         return Integer.valueOf(age);
  488.                     }catch(Exception t) {
  489.                         // ignore
  490.                     }
  491.                 }
  492.             }
  493.             return null;
  494.         }
  495.     }
  496.     
  497.     @Deprecated
  498.     public static List<String> getDirectiveCacheControl(Map<String, String> headers){
  499.         return getCacheControlDirectives(TransportUtils.convertToMapListValues(headers));
  500.     }
  501.     public static List<String> getCacheControlDirectives(Map<String, List<String>> headers){
  502.         
  503.         List<String> l = TransportUtils.getRawObject(headers, HttpConstants.CACHE_STATUS_HTTP_1_1);
  504.         String cacheControl = null;
  505.         if(l!=null && !l.isEmpty()) {
  506.             cacheControl = l.get(0);
  507.         }
  508.         
  509.         List<String> values = new ArrayList<>();
  510.         if(cacheControl!=null) {
  511.             if(cacheControl.contains(",")) {
  512.                 String [] tmp = cacheControl.split(",");
  513.                 for (int i = 0; i < tmp.length; i++) {
  514.                     values.add(tmp[i].trim());
  515.                 }
  516.             }
  517.             else {
  518.                 values.add(cacheControl);
  519.             }
  520.         }
  521.         
  522.         return values;
  523.     }
  524.     
  525.     @Deprecated
  526.     public static List<String> getDirectivePragma(Map<String, String> headers){
  527.         return getPragmaDirectives(TransportUtils.convertToMapListValues(headers));
  528.     }
  529.     public static List<String> getPragmaDirectives(Map<String, List<String>> headers){
  530.         
  531.         List<String> l = TransportUtils.getRawObject(headers, HttpConstants.CACHE_STATUS_HTTP_1_0);
  532.         String cacheControl = null;
  533.         if(l!=null && !l.isEmpty()) {
  534.             cacheControl = l.get(0);
  535.         }
  536.         
  537.         List<String> values = new ArrayList<>();
  538.         if(cacheControl!=null) {
  539.             if(cacheControl.contains(",")) {
  540.                 String [] tmp = cacheControl.split(",");
  541.                 for (int i = 0; i < tmp.length; i++) {
  542.                     values.add(tmp[i].trim());
  543.                 }
  544.             }
  545.             else {
  546.                 values.add(cacheControl);
  547.             }
  548.         }
  549.         
  550.         return values;
  551.     }
  552.     
  553.     
  554.     
  555.     public static void enableHttpUrlConnectionForwardRestrictedHeaders() {
  556.         System.setProperty("sun.net.http.allowRestrictedHeaders", "true");
  557.     }
  558.     
  559.     
  560.     
  561.     public static void setChunkedStreamingMode(HttpURLConnection httpConn, int chunkLength, HttpRequestMethod httpMethod, String contentType) throws UtilsException{
  562.         
  563.         HttpBodyParameters params = new HttpBodyParameters(httpMethod, contentType);
  564.         
  565.         // Devo impostarlo solo se e' previsto un output
  566.         if(params.isDoOutput()){
  567.             httpConn.setChunkedStreamingMode(chunkLength);
  568.         }
  569.     }
  570.     
  571.     public static boolean isHttpBodyPermitted(boolean isRequest,HttpRequestMethod httpMethod, String contentType) throws UtilsException{
  572.         
  573.         HttpBodyParameters params = new HttpBodyParameters(httpMethod, contentType);
  574.         if(isRequest){
  575.             return params.isDoOutput();
  576.         }
  577.         else{
  578.             return params.isDoInput();
  579.         }
  580.         
  581.     }
  582.     

  584.     public static void setStream(HttpURLConnection httpConn, HttpRequestMethod httpMethod) throws UtilsException{
  585.         setStream(httpConn, httpMethod, null);
  586.     }
  587.     public static void setStream(HttpURLConnection httpConn, HttpRequestMethod httpMethod, String contentType) throws UtilsException{
  588.         try{
  589.             HttpBodyParameters params = new HttpBodyParameters(httpMethod, contentType);
  590.                         
  591.             setHttpMethod(httpConn, httpMethod);
  592.             if(params.isDoOutput()){
  593.                 httpConn.setDoOutput(params.isDoOutput());
  594.             }
  595.             if(params.isDoInput()){
  596.                 httpConn.setDoInput(params.isDoInput());
  597.             }
  598.         }catch(Exception e){
  599.             throw new UtilsException(e.getMessage(),e);
  600.         }
  601.     } 
  602.     public static void setHttpMethod(HttpURLConnection httpConn, HttpRequestMethod httpMethod) throws UtilsException {

  604.         // NOTA: comunque l'invio di metodi PATCH,LINK,... funzionano solo con java 8
  605.         
  606.         try {
  607.             if(httpMethod.isStandardMethod()) {
  608.                 httpConn.setRequestMethod(httpMethod.name());
  609.             }
  610.             else {
  611.                 // Fix errore:
  612.                 //java.net.ProtocolException: HTTP method PATCH doesn't support output
  613.                 //  at sun.net.www.protocol.http.HttpURLConnection.getOutputStream(HttpURLConnection.java:1081)
  614.                 try {
  615.                     Object objectModifyMethodField = httpConn;
  616.                     
  617.                      Class<?> classHttpsUrlConnectionImpl = getClassHttpsURLConnectionImpl(); // all'interno c'e' un delegate su cui deve essere impostato il metodo http
  618.                     
  619.                     // Change protected field "method" of public class HttpURLConnection
  620.                     // Nella classe  HttpsURLConnectionImpl il field "method" non viene ereditato dalla superclasse ma deve essere modificato nell'oggetto 'delegate'
  621.                     if(classHttpsUrlConnectionImpl!=null && httpConn.getClass().isAssignableFrom(classHttpsUrlConnectionImpl)) {
  622.                         // Devo gestire il delegate
  623.                         /**System.out.println("GESTIONE HTTPS");*/
  624.                         objectModifyMethodField = readDelegateHttpsURLConnection(classHttpsUrlConnectionImpl, httpConn);
  625.                     }
  626.                     
  627.                     setProtectedFieldValue(HttpURLConnection.class, "method", objectModifyMethodField, httpMethod.name());
  628.                     /**System.out.println("DOPO '"+httpConn.getRequestMethod()+"'");*/
  629.                 } catch (Throwable ex) {
  630.                     throw new Exception("Unsupported Method '"+httpMethod+"' and set by reflection error: "+ex.getMessage(),ex);
  631.                 }
  632.             }
  633.         }catch(Exception e){
  634.             throw new UtilsException(e.getMessage(),e);
  635.         }
  636.     }
  637.     private static void setProtectedFieldValue(Class<?> clazz, String fieldName, Object object, Object newValue) throws Exception {
  638.                 
  639.         /**System.out.println("SET IN '"+object.getClass().getName()+"'");*/
  640.         
  641.         Field field = getField(clazz, fieldName);

  643.         field.setAccessible(true);
  644.         field.set(object, newValue);
  645.         
  646.         /**System.out.println("SET OK IN '"+object.getClass().getName()+"' (field:"+field.getName()+"): "+field.get(object));*/
  647.     }
  648.     private static Field getField(Class<?> clazz, String fieldName) throws UtilsException {
  649.         Field field = null;
  650.         try {
  651.             field = clazz.getDeclaredField(fieldName);
  652.         }catch(Exception e) {
  653.             Field [] f = clazz.getDeclaredFields();
  654.             System.out.println("================= (size:"+f.length+" class:"+clazz.getName()+" fieldName:"+fieldName+") ==========================");
  655.             for (int i = 0; i < f.length; i++) {
  656.                 System.out.println("NOME["+f[i].getName()+"] TIPO["+f[i].getType()+"]");
  657.             }
  658.             f = clazz.getFields();
  659.             System.out.println("================= (FIELDS size:"+f.length+" class:"+clazz.getName()+" fieldName:"+fieldName+") ==========================");
  660.             for (int i = 0; i < f.length; i++) {
  661.                 System.out.println("NOME["+f[i].getName()+"] TIPO["+f[i].getType()+"]");
  662.             }
  663.             throw new UtilsException(e.getMessage(),e);
  664.         }
  665.         return field;
  666.     }
  667.     private static Class<?> classHttpsURLConnectionImpl = null;
  668.     private static Boolean classHttpsURLConnectionImplRead = null;
  669.     private static synchronized void initClassHttpsURLConnectionImpl() {
  670.         if(classHttpsURLConnectionImplRead==null) {
  671.             try {
  672.                 classHttpsURLConnectionImpl = Class.forName("sun.net.www.protocol.https.HttpsURLConnectionImpl");
  673.             }catch(Exception e) {
  674.                 System.out.println("Classe 'sun.net.www.protocol.https.HttpsURLConnectionImpl' non esistente: "+e.getMessage());
  675.             } finally {
  676.                 classHttpsURLConnectionImplRead = true;
  677.             }
  678.         }
  679.     }
  680.     private static Class<?> getClassHttpsURLConnectionImpl() {
  681.         if(classHttpsURLConnectionImplRead==null) {
  682.             initClassHttpsURLConnectionImpl();
  683.         }
  684.         return classHttpsURLConnectionImpl;
  685.     }
  686.     private static Object readDelegateHttpsURLConnection(Class<?> classHttpsUrlConnectionImpl, HttpURLConnection httpConn) throws IllegalArgumentException, IllegalAccessException, UtilsException {
  687.         Field field = getField(classHttpsUrlConnectionImpl, "delegate");
  688.         field.setAccessible(true);
  689.         Object fieldInstance = field.get(httpConn);
  690.         /**System.out.println("Delegate '"+fieldInstance.getClass().getName()+"'");*/
  691.         return fieldInstance;
  692.     }


  695.     
  696.     
  697.     /* ********* HTTP INVOKE ************ */

  699.     // getHTTPResponse (no options)
  700.     
  701.     public static byte[] requestHTTPFile(String path) throws UtilsException{
  702.         return requestHTTPFile(path, HTTP_READ_CONNECTION_TIMEOUT, HTTP_CONNECTION_TIMEOUT, null, null, 
  703.                 (HttpOptions[]) null);
  704.     }
  705.     public static byte[] requestHTTPFile(String path,int readTimeout,int connectTimeout) throws UtilsException{
  706.         return requestHTTPFile(path, readTimeout, connectTimeout, null, null, 
  707.                 (HttpOptions[]) null);
  708.     }
  709.     public static byte[] requestHTTPFile(String path,String username,String password) throws UtilsException{
  710.         return requestHTTPFile(path, HTTP_READ_CONNECTION_TIMEOUT, HTTP_CONNECTION_TIMEOUT, username, password, 
  711.                 (HttpOptions[]) null);
  712.     }   
  713.     public static byte[] requestHTTPFile(String path,int readTimeout,int connectTimeout,String username,String password) throws UtilsException{
  714.         HttpResponse res = getHTTPResponse(path, readTimeout, connectTimeout, username, password, 
  715.                 (HttpOptions[]) null);
  716.         return res.getContent();
  717.     }
  718.     public static HttpResponse getHTTPResponse(String path) throws UtilsException{
  719.         return getHTTPResponse(path, HTTP_READ_CONNECTION_TIMEOUT, HTTP_CONNECTION_TIMEOUT, null, null, 
  720.                 (HttpOptions[]) null);
  721.     }
  722.     public static HttpResponse getHTTPResponse(String path,int readTimeout,int connectTimeout) throws UtilsException{
  723.         return getHTTPResponse(path, readTimeout, connectTimeout, null, null, 
  724.                 (HttpOptions[]) null);
  725.     }
  726.     public static HttpResponse getHTTPResponse(String path,String username,String password) throws UtilsException{
  727.         return getHTTPResponse(path, HTTP_READ_CONNECTION_TIMEOUT, HTTP_CONNECTION_TIMEOUT, username, password, 
  728.                 (HttpOptions[]) null);
  729.     }
  730.     
  731.     public static HttpResponse getHTTPResponse(String path,int readTimeout,int connectTimeout,String username,String password) throws UtilsException{
  732.         return getHTTPResponse(path, readTimeout, connectTimeout, username, password, 
  733.                 (HttpOptions[]) null);
  734.     }
  735.     
  736.     
  737.     // getHTTPResponse (options)
  738.     
  739.     public static byte[] requestHTTPFile(String path,
  740.             HttpOptions ... options) throws UtilsException{
  741.         return requestHTTPFile(path, HTTP_READ_CONNECTION_TIMEOUT, HTTP_CONNECTION_TIMEOUT, null, null,
  742.                 options);
  743.     }
  744.     public static byte[] requestHTTPFile(String path,int readTimeout,int connectTimeout,
  745.             HttpOptions ... options) throws UtilsException{
  746.         return requestHTTPFile(path, readTimeout, connectTimeout, null, null,
  747.                 options);
  748.     }
  749.     public static byte[] requestHTTPFile(String path,String username,String password,
  750.             HttpOptions ... options) throws UtilsException{
  751.         return requestHTTPFile(path, HTTP_READ_CONNECTION_TIMEOUT, HTTP_CONNECTION_TIMEOUT, username, password,
  752.                 options);
  753.     }   
  754.     public static byte[] requestHTTPFile(String path,int readTimeout,int connectTimeout,String username,String password,
  755.             HttpOptions ... options) throws UtilsException{
  756.         HttpResponse res = getHTTPResponse(path, readTimeout, connectTimeout, username, password,
  757.                 options);
  758.         return res.getContent();
  759.     }
  760.     public static HttpResponse getHTTPResponse(String path,
  761.             HttpOptions ... options) throws UtilsException{
  762.         return getHTTPResponse(path, HTTP_READ_CONNECTION_TIMEOUT, HTTP_CONNECTION_TIMEOUT, null, null,
  763.                 options);
  764.     }
  765.     public static HttpResponse getHTTPResponse(String path,int readTimeout,int connectTimeout,
  766.             HttpOptions ... options) throws UtilsException{
  767.         return getHTTPResponse(path, readTimeout, connectTimeout, null, null,
  768.                 options);
  769.     }
  770.     public static HttpResponse getHTTPResponse(String path,String username,String password,
  771.             HttpOptions ... options) throws UtilsException{
  772.         return getHTTPResponse(path, HTTP_READ_CONNECTION_TIMEOUT, HTTP_CONNECTION_TIMEOUT, username, password,
  773.                 options);
  774.     }   
  775.     public static HttpResponse getHTTPResponse(String path,int readTimeout,int connectTimeout,String username,String password,
  776.             HttpOptions ... options) throws UtilsException{
  777.         
  778.         HttpRequest httpRequest = new HttpRequest();
  779.         httpRequest.setUrl(path);
  780.         httpRequest.setReadTimeout(readTimeout);
  781.         httpRequest.setConnectTimeout(connectTimeout);
  782.         httpRequest.setUsername(username);
  783.         httpRequest.setPassword(password);
  784.         httpRequest.setMethod(HttpRequestMethod.GET);
  785.         
  786.         if(options!=null && options.length>0) {
  787.             for (HttpOptions httpOptions : options) {
  788.                 httpOptions.fill(httpRequest);
  789.             }
  790.         }
  791.         
  792.         HttpResponse response = null;
  793.         try{
  794.             response = httpInvoke(httpRequest);
  795.             
  796.         }catch(Exception e){
  797.             throw new UtilsException("Utilities.requestHTTPFile error "+e.getMessage(),e);
  798.         }
  799.         if(response.getResultHTTPOperation()==404){
  800.             throw new UtilsException("404");
  801.         }
  802.         return response;
  803.         
  804.     }
  805.     
  806.     
  807.     
  808.     
  809.     
  810.     // getHTTPSResponse (no options)
  811.     
  812.     public static byte[] requestHTTPSFile(String path,
  813.             String trustStore, String trustStorePassword, String trustStoreType) throws UtilsException{
  814.         HttpResponse res = getHTTPSResponse(path, HTTP_READ_CONNECTION_TIMEOUT, HTTP_CONNECTION_TIMEOUT, null, null,
  815.                 trustStore, trustStorePassword, trustStoreType,
  816.                 null, null, 
  817.                 (HttpOptions[]) null);
  818.         return res.getContent();
  819.     }
  820.     public static byte[] requestHTTPSFile(String path,
  821.             String trustStore, String trustStorePassword, String trustStoreType,
  822.             String crlPath) throws UtilsException{
  823.         HttpResponse res = getHTTPSResponse(path, HTTP_READ_CONNECTION_TIMEOUT, HTTP_CONNECTION_TIMEOUT, null, null,
  824.                 trustStore, trustStorePassword, trustStoreType,
  825.                 crlPath, null, 
  826.                 (HttpOptions[]) null);
  827.         return res.getContent();
  828.     }
  829.     public static byte[] requestHTTPSFile(String path,
  830.             String trustStore, String trustStorePassword, String trustStoreType,
  831.             IOCSPValidator ocspValidator) throws UtilsException{
  832.         HttpResponse res = getHTTPSResponse(path, HTTP_READ_CONNECTION_TIMEOUT, HTTP_CONNECTION_TIMEOUT, null, null,
  833.                 trustStore, trustStorePassword, trustStoreType,
  834.                 null, ocspValidator, 
  835.                 (HttpOptions[]) null);
  836.         return res.getContent();
  837.     }
  838.     public static byte[] requestHTTPSFile(String path,
  839.             String trustStore, String trustStorePassword, String trustStoreType,
  840.             String crlPath, IOCSPValidator ocspValidator) throws UtilsException{
  841.         HttpResponse res = getHTTPSResponse(path, HTTP_READ_CONNECTION_TIMEOUT, HTTP_CONNECTION_TIMEOUT, null, null,
  842.                 trustStore, trustStorePassword, trustStoreType,
  843.                 crlPath, ocspValidator, 
  844.                 (HttpOptions[]) null);
  845.         return res.getContent();
  846.     }
  847.     
  848.     public static byte[] requestHTTPSFile(String path,int readTimeout,int connectTimeout,
  849.             String trustStore, String trustStorePassword, String trustStoreType) throws UtilsException{
  850.         HttpResponse res = getHTTPSResponse(path, readTimeout, connectTimeout, null, null,
  851.                 trustStore, trustStorePassword, trustStoreType,
  852.                 null, null, 
  853.                 (HttpOptions[]) null);
  854.         return res.getContent();
  855.     }
  856.     public static byte[] requestHTTPSFile(String path,int readTimeout,int connectTimeout,
  857.             String trustStore, String trustStorePassword, String trustStoreType,
  858.             String crlPath) throws UtilsException{
  859.         HttpResponse res = getHTTPSResponse(path, readTimeout, connectTimeout, null, null,
  860.                 trustStore, trustStorePassword, trustStoreType,
  861.                 crlPath, null, 
  862.                 (HttpOptions[]) null);
  863.         return res.getContent();
  864.     }
  865.     public static byte[] requestHTTPSFile(String path,int readTimeout,int connectTimeout,
  866.             String trustStore, String trustStorePassword, String trustStoreType,
  867.             IOCSPValidator ocspValidator) throws UtilsException{
  868.         HttpResponse res = getHTTPSResponse(path, readTimeout, connectTimeout, null, null,
  869.                 trustStore, trustStorePassword, trustStoreType,
  870.                 null, ocspValidator, 
  871.                 (HttpOptions[]) null);
  872.         return res.getContent();
  873.     }
  874.     public static byte[] requestHTTPSFile(String path,int readTimeout,int connectTimeout,
  875.             String trustStore, String trustStorePassword, String trustStoreType,
  876.             String crlPath, IOCSPValidator ocspValidator) throws UtilsException{
  877.         HttpResponse res = getHTTPSResponse(path, readTimeout, connectTimeout, null, null,
  878.                 trustStore, trustStorePassword, trustStoreType,
  879.                 crlPath, ocspValidator, 
  880.                 (HttpOptions[]) null);
  881.         return res.getContent();
  882.     }
  883.     
  884.     public static byte[] requestHTTPSFile(String path,String username,String password,
  885.             String trustStore, String trustStorePassword, String trustStoreType) throws UtilsException{
  886.         HttpResponse res = getHTTPSResponse(path, HTTP_READ_CONNECTION_TIMEOUT, HTTP_CONNECTION_TIMEOUT, username, password,
  887.                 trustStore, trustStorePassword, trustStoreType,
  888.                 null, null, 
  889.                 (HttpOptions[]) null);
  890.         return res.getContent();
  891.     }
  892.     public static byte[] requestHTTPSFile(String path,String username,String password,
  893.             String trustStore, String trustStorePassword, String trustStoreType,
  894.             String crlPath) throws UtilsException{
  895.         HttpResponse res = getHTTPSResponse(path, HTTP_READ_CONNECTION_TIMEOUT, HTTP_CONNECTION_TIMEOUT, username, password,
  896.                 trustStore, trustStorePassword, trustStoreType,
  897.                 crlPath, null, 
  898.                 (HttpOptions[]) null);
  899.         return res.getContent();
  900.     }   
  901.     public static byte[] requestHTTPSFile(String path,String username,String password,
  902.             String trustStore, String trustStorePassword, String trustStoreType,
  903.             IOCSPValidator ocspValidator) throws UtilsException{
  904.         HttpResponse res = getHTTPSResponse(path, HTTP_READ_CONNECTION_TIMEOUT, HTTP_CONNECTION_TIMEOUT, username, password,
  905.                 trustStore, trustStorePassword, trustStoreType,
  906.                 null, ocspValidator, 
  907.                 (HttpOptions[]) null);
  908.         return res.getContent();
  909.     }   
  910.     public static byte[] requestHTTPSFile(String path,String username,String password,
  911.             String trustStore, String trustStorePassword, String trustStoreType,
  912.             String crlPath, IOCSPValidator ocspValidator) throws UtilsException{
  913.         HttpResponse res = getHTTPSResponse(path, HTTP_READ_CONNECTION_TIMEOUT, HTTP_CONNECTION_TIMEOUT, username, password,
  914.                 trustStore, trustStorePassword, trustStoreType,
  915.                 crlPath, ocspValidator, 
  916.                 (HttpOptions[]) null);
  917.         return res.getContent();
  918.     }   
  919.     
  920.     public static byte[] requestHTTPSFile(String path,int readTimeout,int connectTimeout,String username,String password,
  921.             String trustStore, String trustStorePassword, String trustStoreType) throws UtilsException{
  922.         HttpResponse res = getHTTPSResponse(path, readTimeout, connectTimeout, username, password,
  923.                 trustStore, trustStorePassword, trustStoreType,
  924.                 null, null, 
  925.                 (HttpOptions[]) null);
  926.         return res.getContent();
  927.     }
  928.     public static byte[] requestHTTPSFile(String path,int readTimeout,int connectTimeout,String username,String password,
  929.             String trustStore, String trustStorePassword, String trustStoreType,
  930.             String crlPath) throws UtilsException{
  931.         HttpResponse res = getHTTPSResponse(path, readTimeout, connectTimeout, username, password,
  932.                 trustStore, trustStorePassword, trustStoreType,
  933.                 crlPath, null, 
  934.                 (HttpOptions[]) null);
  935.         return res.getContent();
  936.     }
  937.     public static byte[] requestHTTPSFile(String path,int readTimeout,int connectTimeout,String username,String password,
  938.             String trustStore, String trustStorePassword, String trustStoreType,
  939.             IOCSPValidator ocspValidator) throws UtilsException{
  940.         HttpResponse res = getHTTPSResponse(path, readTimeout, connectTimeout, username, password,
  941.                 trustStore, trustStorePassword, trustStoreType,
  942.                 null, ocspValidator, 
  943.                 (HttpOptions[]) null);
  944.         return res.getContent();
  945.     }
  946.     public static byte[] requestHTTPSFile(String path,int readTimeout,int connectTimeout,String username,String password,
  947.             String trustStore, String trustStorePassword, String trustStoreType,
  948.             String crlPath, IOCSPValidator ocspValidator) throws UtilsException{
  949.         HttpResponse res = getHTTPSResponse(path, readTimeout, connectTimeout, username, password,
  950.                 trustStore, trustStorePassword, trustStoreType,
  951.                 null, ocspValidator, 
  952.                 (HttpOptions[]) null);
  953.         return res.getContent();
  954.     }
  955.     
  956.     public static HttpResponse getHTTPSResponse(String path,
  957.             String trustStore, String trustStorePassword, String trustStoreType) throws UtilsException{
  958.         return getHTTPSResponse(path, HTTP_READ_CONNECTION_TIMEOUT, HTTP_CONNECTION_TIMEOUT, null, null,
  959.                 trustStore, trustStorePassword, trustStoreType,
  960.                 null, null, 
  961.                 (HttpOptions[]) null);
  962.     }
  963.     public static HttpResponse getHTTPSResponse(String path,
  964.             String trustStore, String trustStorePassword, String trustStoreType,
  965.             String crlPath) throws UtilsException{
  966.         return getHTTPSResponse(path, HTTP_READ_CONNECTION_TIMEOUT, HTTP_CONNECTION_TIMEOUT, null, null,
  967.                 trustStore, trustStorePassword, trustStoreType,
  968.                 crlPath, null, 
  969.                 (HttpOptions[]) null);
  970.     }
  971.     public static HttpResponse getHTTPSResponse(String path,
  972.             String trustStore, String trustStorePassword, String trustStoreType,
  973.             IOCSPValidator ocspValidator) throws UtilsException{
  974.         return getHTTPSResponse(path, HTTP_READ_CONNECTION_TIMEOUT, HTTP_CONNECTION_TIMEOUT, null, null,
  975.                 trustStore, trustStorePassword, trustStoreType,
  976.                 null, ocspValidator, 
  977.                 (HttpOptions[]) null);
  978.     }
  979.     public static HttpResponse getHTTPSResponse(String path,
  980.             String trustStore, String trustStorePassword, String trustStoreType,
  981.             String crlPath, IOCSPValidator ocspValidator) throws UtilsException{
  982.         return getHTTPSResponse(path, HTTP_READ_CONNECTION_TIMEOUT, HTTP_CONNECTION_TIMEOUT, null, null,
  983.                 trustStore, trustStorePassword, trustStoreType,
  984.                 crlPath, ocspValidator, 
  985.                 (HttpOptions[]) null);
  986.     }
  987.     
  988.     public static HttpResponse getHTTPSResponse(String path,int readTimeout,int connectTimeout,
  989.             String trustStore, String trustStorePassword, String trustStoreType) throws UtilsException{
  990.         return getHTTPSResponse(path, readTimeout, connectTimeout, null, null,
  991.                 trustStore, trustStorePassword, trustStoreType,
  992.                 null, null, 
  993.                 (HttpOptions[]) null);
  994.     }
  995.     public static HttpResponse getHTTPSResponse(String path,int readTimeout,int connectTimeout,
  996.             String trustStore, String trustStorePassword, String trustStoreType,
  997.             String crlPath) throws UtilsException{
  998.         return getHTTPSResponse(path, readTimeout, connectTimeout, null, null,
  999.                 trustStore, trustStorePassword, trustStoreType,
  1000.                 crlPath, null, 
  1001.                 (HttpOptions[]) null);
  1002.     }
  1003.     public static HttpResponse getHTTPSResponse(String path,int readTimeout,int connectTimeout,
  1004.             String trustStore, String trustStorePassword, String trustStoreType,
  1005.             IOCSPValidator ocspValidator) throws UtilsException{
  1006.         return getHTTPSResponse(path, readTimeout, connectTimeout, null, null,
  1007.                 trustStore, trustStorePassword, trustStoreType,
  1008.                 null, ocspValidator, 
  1009.                 (HttpOptions[]) null);
  1010.     }
  1011.     public static HttpResponse getHTTPSResponse(String path,int readTimeout,int connectTimeout,
  1012.             String trustStore, String trustStorePassword, String trustStoreType,
  1013.             String crlPath, IOCSPValidator ocspValidator) throws UtilsException{
  1014.         return getHTTPSResponse(path, readTimeout, connectTimeout, null, null,
  1015.                 trustStore, trustStorePassword, trustStoreType,
  1016.                 crlPath, ocspValidator, 
  1017.                 (HttpOptions[]) null);
  1018.     }
  1019.     
  1020.     public static HttpResponse getHTTPSResponse(String path,String username,String password,
  1021.             String trustStore, String trustStorePassword, String trustStoreType) throws UtilsException{
  1022.         return getHTTPSResponse(path, HTTP_READ_CONNECTION_TIMEOUT, HTTP_CONNECTION_TIMEOUT, username, password,
  1023.                 trustStore, trustStorePassword, trustStoreType,
  1024.                 null, null, 
  1025.                 (HttpOptions[]) null);
  1026.     }
  1027.     public static HttpResponse getHTTPSResponse(String path,String username,String password,
  1028.             String trustStore, String trustStorePassword, String trustStoreType,
  1029.             String crlPath) throws UtilsException{
  1030.         return getHTTPSResponse(path, HTTP_READ_CONNECTION_TIMEOUT, HTTP_CONNECTION_TIMEOUT, username, password,
  1031.                 trustStore, trustStorePassword, trustStoreType,
  1032.                 crlPath, null, 
  1033.                 (HttpOptions[]) null);
  1034.     }
  1035.     public static HttpResponse getHTTPSResponse(String path,String username,String password,
  1036.             String trustStore, String trustStorePassword, String trustStoreType,
  1037.             IOCSPValidator ocspValidator) throws UtilsException{
  1038.         return getHTTPSResponse(path, HTTP_READ_CONNECTION_TIMEOUT, HTTP_CONNECTION_TIMEOUT, username, password,
  1039.                 trustStore, trustStorePassword, trustStoreType,
  1040.                 null, ocspValidator, 
  1041.                 (HttpOptions[]) null);
  1042.     }
  1043.     public static HttpResponse getHTTPSResponse(String path,String username,String password,
  1044.             String trustStore, String trustStorePassword, String trustStoreType,
  1045.             String crlPath, IOCSPValidator ocspValidator) throws UtilsException{
  1046.         return getHTTPSResponse(path, HTTP_READ_CONNECTION_TIMEOUT, HTTP_CONNECTION_TIMEOUT, username, password,
  1047.                 trustStore, trustStorePassword, trustStoreType,
  1048.                 crlPath, ocspValidator, 
  1049.                 (HttpOptions[]) null);
  1050.     }
  1051.     
  1052.     public static HttpResponse getHTTPSResponse(String path,int readTimeout,int connectTimeout,String username,String password,
  1053.             String trustStore, String trustStorePassword, String trustStoreType) throws UtilsException{
  1054.         return getHTTPSResponse(path,readTimeout,connectTimeout,username,password,
  1055.                 trustStore, trustStorePassword, trustStoreType,
  1056.                 null, null, 
  1057.                 (HttpOptions[]) null);
  1058.     }
  1059.     public static HttpResponse getHTTPSResponse(String path,int readTimeout,int connectTimeout,String username,String password,
  1060.             String trustStore, String trustStorePassword, String trustStoreType,
  1061.             String crlPath) throws UtilsException{
  1062.         return getHTTPSResponse(path,readTimeout,connectTimeout,username,password,
  1063.                 trustStore, trustStorePassword, trustStoreType,
  1064.                 crlPath, null, 
  1065.                 (HttpOptions[]) null);
  1066.     }
  1067.     public static HttpResponse getHTTPSResponse(String path,int readTimeout,int connectTimeout,String username,String password,
  1068.             String trustStore, String trustStorePassword, String trustStoreType,
  1069.             IOCSPValidator ocspValidator) throws UtilsException{
  1070.         return getHTTPSResponse(path,readTimeout,connectTimeout,username,password,
  1071.                 trustStore, trustStorePassword, trustStoreType,
  1072.                 null, ocspValidator, 
  1073.                 (HttpOptions[]) null);
  1074.     }
  1075.     public static HttpResponse getHTTPSResponse(String path,int readTimeout,int connectTimeout,String username,String password,
  1076.             String trustStore, String trustStorePassword, String trustStoreType,
  1077.             String crlPath, IOCSPValidator ocspValidator) throws UtilsException{
  1078.         return getHTTPSResponse(path,readTimeout,connectTimeout,username,password,
  1079.                 trustStore, trustStorePassword, trustStoreType,
  1080.                 crlPath, ocspValidator, 
  1081.                 (HttpOptions[]) null);
  1082.     }
  1083.     
  1084.     
  1085.     // getHTTPSResponse (options)
  1086.     
  1087.     public static byte[] requestHTTPSFile(String path,
  1088.             String trustStore, String trustStorePassword, String trustStoreType,
  1089.             HttpOptions ... options) throws UtilsException{
  1090.         HttpResponse res = getHTTPSResponse(path, HTTP_READ_CONNECTION_TIMEOUT, HTTP_CONNECTION_TIMEOUT, null, null,
  1091.                 trustStore, trustStorePassword, trustStoreType,
  1092.                 null, null,
  1093.                 options);
  1094.         return res.getContent();
  1095.     }
  1096.     public static byte[] requestHTTPSFile(String path,
  1097.             String trustStore, String trustStorePassword, String trustStoreType,
  1098.             String crlPath,
  1099.             HttpOptions ... options) throws UtilsException{
  1100.         HttpResponse res = getHTTPSResponse(path, HTTP_READ_CONNECTION_TIMEOUT, HTTP_CONNECTION_TIMEOUT, null, null,
  1101.                 trustStore, trustStorePassword, trustStoreType,
  1102.                 crlPath, null,
  1103.                 options);
  1104.         return res.getContent();
  1105.     }
  1106.     public static byte[] requestHTTPSFile(String path,
  1107.             String trustStore, String trustStorePassword, String trustStoreType,
  1108.             IOCSPValidator ocspValidator,
  1109.             HttpOptions ... options) throws UtilsException{
  1110.         HttpResponse res = getHTTPSResponse(path, HTTP_READ_CONNECTION_TIMEOUT, HTTP_CONNECTION_TIMEOUT, null, null,
  1111.                 trustStore, trustStorePassword, trustStoreType,
  1112.                 null, ocspValidator,
  1113.                 options);
  1114.         return res.getContent();
  1115.     }
  1116.     public static byte[] requestHTTPSFile(String path,
  1117.             String trustStore, String trustStorePassword, String trustStoreType,
  1118.             String crlPath, IOCSPValidator ocspValidator,
  1119.             HttpOptions ... options) throws UtilsException{
  1120.         HttpResponse res = getHTTPSResponse(path, HTTP_READ_CONNECTION_TIMEOUT, HTTP_CONNECTION_TIMEOUT, null, null,
  1121.                 trustStore, trustStorePassword, trustStoreType,
  1122.                 crlPath, ocspValidator,
  1123.                 options);
  1124.         return res.getContent();
  1125.     }
  1126.     
  1127.     public static byte[] requestHTTPSFile(String path,int readTimeout,int connectTimeout,
  1128.             String trustStore, String trustStorePassword, String trustStoreType,
  1129.             HttpOptions ... options) throws UtilsException{
  1130.         HttpResponse res = getHTTPSResponse(path, readTimeout, connectTimeout, null, null,
  1131.                 trustStore, trustStorePassword, trustStoreType,
  1132.                 null, null,
  1133.                 options);
  1134.         return res.getContent();
  1135.     }
  1136.     public static byte[] requestHTTPSFile(String path,int readTimeout,int connectTimeout,
  1137.             String trustStore, String trustStorePassword, String trustStoreType,
  1138.             String crlPath,
  1139.             HttpOptions ... options) throws UtilsException{
  1140.         HttpResponse res = getHTTPSResponse(path, readTimeout, connectTimeout, null, null,
  1141.                 trustStore, trustStorePassword, trustStoreType,
  1142.                 crlPath, null,
  1143.                 options);
  1144.         return res.getContent();
  1145.     }
  1146.     public static byte[] requestHTTPSFile(String path,int readTimeout,int connectTimeout,
  1147.             String trustStore, String trustStorePassword, String trustStoreType,
  1148.             IOCSPValidator ocspValidator,
  1149.             HttpOptions ... options) throws UtilsException{
  1150.         HttpResponse res = getHTTPSResponse(path, readTimeout, connectTimeout, null, null,
  1151.                 trustStore, trustStorePassword, trustStoreType,
  1152.                 null, ocspValidator,
  1153.                 options);
  1154.         return res.getContent();
  1155.     }
  1156.     public static byte[] requestHTTPSFile(String path,int readTimeout,int connectTimeout,
  1157.             String trustStore, String trustStorePassword, String trustStoreType,
  1158.             String crlPath, IOCSPValidator ocspValidator,
  1159.             HttpOptions ... options) throws UtilsException{
  1160.         HttpResponse res = getHTTPSResponse(path, readTimeout, connectTimeout, null, null,
  1161.                 trustStore, trustStorePassword, trustStoreType,
  1162.                 crlPath, ocspValidator,
  1163.                 options);
  1164.         return res.getContent();
  1165.     }
  1166.     
  1167.     public static byte[] requestHTTPSFile(String path,String username,String password,
  1168.             String trustStore, String trustStorePassword, String trustStoreType,
  1169.             HttpOptions ... options) throws UtilsException{
  1170.         HttpResponse res = getHTTPSResponse(path, HTTP_READ_CONNECTION_TIMEOUT, HTTP_CONNECTION_TIMEOUT, username, password,
  1171.                 trustStore, trustStorePassword, trustStoreType,
  1172.                 null, null,
  1173.                 options);
  1174.         return res.getContent();
  1175.     }
  1176.     public static byte[] requestHTTPSFile(String path,String username,String password,
  1177.             String trustStore, String trustStorePassword, String trustStoreType,
  1178.             String crlPath,
  1179.             HttpOptions ... options) throws UtilsException{
  1180.         HttpResponse res = getHTTPSResponse(path, HTTP_READ_CONNECTION_TIMEOUT, HTTP_CONNECTION_TIMEOUT, username, password,
  1181.                 trustStore, trustStorePassword, trustStoreType,
  1182.                 crlPath, null,
  1183.                 options);
  1184.         return res.getContent();
  1185.     }   
  1186.     public static byte[] requestHTTPSFile(String path,String username,String password,
  1187.             String trustStore, String trustStorePassword, String trustStoreType,
  1188.             IOCSPValidator ocspValidator,
  1189.             HttpOptions ... options) throws UtilsException{
  1190.         HttpResponse res = getHTTPSResponse(path, HTTP_READ_CONNECTION_TIMEOUT, HTTP_CONNECTION_TIMEOUT, username, password,
  1191.                 trustStore, trustStorePassword, trustStoreType,
  1192.                 null, ocspValidator,
  1193.                 options);
  1194.         return res.getContent();
  1195.     }   
  1196.     public static byte[] requestHTTPSFile(String path,String username,String password,
  1197.             String trustStore, String trustStorePassword, String trustStoreType,
  1198.             String crlPath, IOCSPValidator ocspValidator,
  1199.             HttpOptions ... options) throws UtilsException{
  1200.         HttpResponse res = getHTTPSResponse(path, HTTP_READ_CONNECTION_TIMEOUT, HTTP_CONNECTION_TIMEOUT, username, password,
  1201.                 trustStore, trustStorePassword, trustStoreType,
  1202.                 crlPath, ocspValidator,
  1203.                 options);
  1204.         return res.getContent();
  1205.     }   
  1206.     
  1207.     public static byte[] requestHTTPSFile(String path,int readTimeout,int connectTimeout,String username,String password,
  1208.             String trustStore, String trustStorePassword, String trustStoreType,
  1209.             HttpOptions ... options) throws UtilsException{
  1210.         HttpResponse res = getHTTPSResponse(path, readTimeout, connectTimeout, username, password,
  1211.                 trustStore, trustStorePassword, trustStoreType,
  1212.                 null, null,
  1213.                 options);
  1214.         return res.getContent();
  1215.     }
  1216.     public static byte[] requestHTTPSFile(String path,int readTimeout,int connectTimeout,String username,String password,
  1217.             String trustStore, String trustStorePassword, String trustStoreType,
  1218.             String crlPath,
  1219.             HttpOptions ... options) throws UtilsException{
  1220.         HttpResponse res = getHTTPSResponse(path, readTimeout, connectTimeout, username, password,
  1221.                 trustStore, trustStorePassword, trustStoreType,
  1222.                 crlPath, null,
  1223.                 options);
  1224.         return res.getContent();
  1225.     }
  1226.     public static byte[] requestHTTPSFile(String path,int readTimeout,int connectTimeout,String username,String password,
  1227.             String trustStore, String trustStorePassword, String trustStoreType,
  1228.             IOCSPValidator ocspValidator,
  1229.             HttpOptions ... options) throws UtilsException{
  1230.         HttpResponse res = getHTTPSResponse(path, readTimeout, connectTimeout, username, password,
  1231.                 trustStore, trustStorePassword, trustStoreType,
  1232.                 null, ocspValidator,
  1233.                 options);
  1234.         return res.getContent();
  1235.     }
  1236.     public static byte[] requestHTTPSFile(String path,int readTimeout,int connectTimeout,String username,String password,
  1237.             String trustStore, String trustStorePassword, String trustStoreType,
  1238.             String crlPath, IOCSPValidator ocspValidator,
  1239.             HttpOptions ... options) throws UtilsException{
  1240.         HttpResponse res = getHTTPSResponse(path, readTimeout, connectTimeout, username, password,
  1241.                 trustStore, trustStorePassword, trustStoreType,
  1242.                 null, ocspValidator,
  1243.                 options);
  1244.         return res.getContent();
  1245.     }
  1246.     
  1247.     public static HttpResponse getHTTPSResponse(String path,
  1248.             String trustStore, String trustStorePassword, String trustStoreType,
  1249.             HttpOptions ... options) throws UtilsException{
  1250.         return getHTTPSResponse(path, HTTP_READ_CONNECTION_TIMEOUT, HTTP_CONNECTION_TIMEOUT, null, null,
  1251.                 trustStore, trustStorePassword, trustStoreType,
  1252.                 null, null,
  1253.                 options);
  1254.     }
  1255.     public static HttpResponse getHTTPSResponse(String path,
  1256.             String trustStore, String trustStorePassword, String trustStoreType,
  1257.             String crlPath,
  1258.             HttpOptions ... options) throws UtilsException{
  1259.         return getHTTPSResponse(path, HTTP_READ_CONNECTION_TIMEOUT, HTTP_CONNECTION_TIMEOUT, null, null,
  1260.                 trustStore, trustStorePassword, trustStoreType,
  1261.                 crlPath, null,
  1262.                 options);
  1263.     }
  1264.     public static HttpResponse getHTTPSResponse(String path,
  1265.             String trustStore, String trustStorePassword, String trustStoreType,
  1266.             IOCSPValidator ocspValidator,
  1267.             HttpOptions ... options) throws UtilsException{
  1268.         return getHTTPSResponse(path, HTTP_READ_CONNECTION_TIMEOUT, HTTP_CONNECTION_TIMEOUT, null, null,
  1269.                 trustStore, trustStorePassword, trustStoreType,
  1270.                 null, ocspValidator,
  1271.                 options);
  1272.     }
  1273.     public static HttpResponse getHTTPSResponse(String path,
  1274.             String trustStore, String trustStorePassword, String trustStoreType,
  1275.             String crlPath, IOCSPValidator ocspValidator,
  1276.             HttpOptions ... options) throws UtilsException{
  1277.         return getHTTPSResponse(path, HTTP_READ_CONNECTION_TIMEOUT, HTTP_CONNECTION_TIMEOUT, null, null,
  1278.                 trustStore, trustStorePassword, trustStoreType,
  1279.                 crlPath, ocspValidator,
  1280.                 options);
  1281.     }
  1282.     
  1283.     public static HttpResponse getHTTPSResponse(String path,int readTimeout,int connectTimeout,
  1284.             String trustStore, String trustStorePassword, String trustStoreType,
  1285.             HttpOptions ... options) throws UtilsException{
  1286.         return getHTTPSResponse(path, readTimeout, connectTimeout, null, null,
  1287.                 trustStore, trustStorePassword, trustStoreType,
  1288.                 null, null,
  1289.                 options);
  1290.     }
  1291.     public static HttpResponse getHTTPSResponse(String path,int readTimeout,int connectTimeout,
  1292.             String trustStore, String trustStorePassword, String trustStoreType,
  1293.             String crlPath,
  1294.             HttpOptions ... options) throws UtilsException{
  1295.         return getHTTPSResponse(path, readTimeout, connectTimeout, null, null,
  1296.                 trustStore, trustStorePassword, trustStoreType,
  1297.                 crlPath, null,
  1298.                 options);
  1299.     }
  1300.     public static HttpResponse getHTTPSResponse(String path,int readTimeout,int connectTimeout,
  1301.             String trustStore, String trustStorePassword, String trustStoreType,
  1302.             IOCSPValidator ocspValidator,
  1303.             HttpOptions ... options) throws UtilsException{
  1304.         return getHTTPSResponse(path, readTimeout, connectTimeout, null, null,
  1305.                 trustStore, trustStorePassword, trustStoreType,
  1306.                 null, ocspValidator,
  1307.                 options);
  1308.     }
  1309.     public static HttpResponse getHTTPSResponse(String path,int readTimeout,int connectTimeout,
  1310.             String trustStore, String trustStorePassword, String trustStoreType,
  1311.             String crlPath, IOCSPValidator ocspValidator,
  1312.             HttpOptions ... options) throws UtilsException{
  1313.         return getHTTPSResponse(path, readTimeout, connectTimeout, null, null,
  1314.                 trustStore, trustStorePassword, trustStoreType,
  1315.                 crlPath, ocspValidator,
  1316.                 options);
  1317.     }
  1318.     
  1319.     public static HttpResponse getHTTPSResponse(String path,String username,String password,
  1320.             String trustStore, String trustStorePassword, String trustStoreType,
  1321.             HttpOptions ... options) throws UtilsException{
  1322.         return getHTTPSResponse(path, HTTP_READ_CONNECTION_TIMEOUT, HTTP_CONNECTION_TIMEOUT, username, password,
  1323.                 trustStore, trustStorePassword, trustStoreType,
  1324.                 null, null,
  1325.                 options);
  1326.     }
  1327.     public static HttpResponse getHTTPSResponse(String path,String username,String password,
  1328.             String trustStore, String trustStorePassword, String trustStoreType,
  1329.             String crlPath,
  1330.             HttpOptions ... options) throws UtilsException{
  1331.         return getHTTPSResponse(path, HTTP_READ_CONNECTION_TIMEOUT, HTTP_CONNECTION_TIMEOUT, username, password,
  1332.                 trustStore, trustStorePassword, trustStoreType,
  1333.                 crlPath, null,
  1334.                 options);
  1335.     }
  1336.     public static HttpResponse getHTTPSResponse(String path,String username,String password,
  1337.             String trustStore, String trustStorePassword, String trustStoreType,
  1338.             IOCSPValidator ocspValidator,
  1339.             HttpOptions ... options) throws UtilsException{
  1340.         return getHTTPSResponse(path, HTTP_READ_CONNECTION_TIMEOUT, HTTP_CONNECTION_TIMEOUT, username, password,
  1341.                 trustStore, trustStorePassword, trustStoreType,
  1342.                 null, ocspValidator,
  1343.                 options);
  1344.     }
  1345.     public static HttpResponse getHTTPSResponse(String path,String username,String password,
  1346.             String trustStore, String trustStorePassword, String trustStoreType,
  1347.             String crlPath, IOCSPValidator ocspValidator,
  1348.             HttpOptions ... options) throws UtilsException{
  1349.         return getHTTPSResponse(path, HTTP_READ_CONNECTION_TIMEOUT, HTTP_CONNECTION_TIMEOUT, username, password,
  1350.                 trustStore, trustStorePassword, trustStoreType,
  1351.                 crlPath, ocspValidator,
  1352.                 options);
  1353.     }
  1354.     
  1355.     public static HttpResponse getHTTPSResponse(String path,int readTimeout,int connectTimeout,String username,String password,
  1356.             String trustStore, String trustStorePassword, String trustStoreType,
  1357.             HttpOptions ... options) throws UtilsException{
  1358.         return getHTTPSResponse(path,readTimeout,connectTimeout,username,password,
  1359.                 trustStore, trustStorePassword, trustStoreType,
  1360.                 null, null,
  1361.                 options);
  1362.     }
  1363.     public static HttpResponse getHTTPSResponse(String path,int readTimeout,int connectTimeout,String username,String password,
  1364.             String trustStore, String trustStorePassword, String trustStoreType,
  1365.             String crlPath,
  1366.             HttpOptions ... options) throws UtilsException{
  1367.         return getHTTPSResponse(path,readTimeout,connectTimeout,username,password,
  1368.                 trustStore, trustStorePassword, trustStoreType,
  1369.                 crlPath, null,
  1370.                 options);
  1371.     }
  1372.     public static HttpResponse getHTTPSResponse(String path,int readTimeout,int connectTimeout,String username,String password,
  1373.             String trustStore, String trustStorePassword, String trustStoreType,
  1374.             IOCSPValidator ocspValidator,
  1375.             HttpOptions ... options) throws UtilsException{
  1376.         return getHTTPSResponse(path,readTimeout,connectTimeout,username,password,
  1377.                 trustStore, trustStorePassword, trustStoreType,
  1378.                 null, ocspValidator,
  1379.                 options);
  1380.     }
  1381.     public static HttpResponse getHTTPSResponse(String path,int readTimeout,int connectTimeout,String username,String password,
  1382.             String trustStore, String trustStorePassword, String trustStoreType,
  1383.             String crlPath, IOCSPValidator ocspValidator,
  1384.             HttpOptions ... options) throws UtilsException{
  1385.         
  1386.         HttpRequest httpRequest = new HttpRequest();
  1387.         httpRequest.setUrl(path);
  1388.         httpRequest.setReadTimeout(readTimeout);
  1389.         httpRequest.setConnectTimeout(connectTimeout);
  1390.         httpRequest.setUsername(username);
  1391.         httpRequest.setPassword(password);
  1392.         httpRequest.setMethod(HttpRequestMethod.GET);
  1393.         
  1394.         httpRequest.setTrustStorePath(trustStore);
  1395.         httpRequest.setTrustStorePassword(trustStorePassword);
  1396.         httpRequest.setTrustStoreType(trustStoreType);
  1397.         httpRequest.setCrlPath(crlPath);
  1398.         httpRequest.setOcspValidator(ocspValidator);
  1399.         
  1400.         if(options!=null && options.length>0) {
  1401.             for (HttpOptions httpOptions : options) {
  1402.                 httpOptions.fill(httpRequest);
  1403.             }
  1404.         }
  1405.         
  1406.         HttpResponse response = null;
  1407.         try{
  1408.             response = httpInvoke(httpRequest);
  1409.             
  1410.         }catch(Exception e){
  1411.             throw new UtilsException("Utilities.requestHTTPFile error "+e.getMessage(),e);
  1412.         }
  1413.         if(response.getResultHTTPOperation()==404){
  1414.             throw new UtilsException("404");
  1415.         }
  1416.         return response;
  1417.         
  1418.     }
  1419.     
  1420.     
  1421.     
  1422.     // getHTTPSResponse (no options)
  1423.     
  1424.     public static byte[] requestHTTPSFile(String path,
  1425.             KeyStore trustStore) throws UtilsException{
  1426.         HttpResponse res = getHTTPSResponse(path, HTTP_READ_CONNECTION_TIMEOUT, HTTP_CONNECTION_TIMEOUT, null, null,
  1427.                 trustStore, null, null, 
  1428.                 (HttpOptions[]) null);
  1429.         return res.getContent();
  1430.     }
  1431.     public static byte[] requestHTTPSFile(String path,
  1432.             KeyStore trustStore, CertStore crlStore) throws UtilsException{
  1433.         HttpResponse res = getHTTPSResponse(path, HTTP_READ_CONNECTION_TIMEOUT, HTTP_CONNECTION_TIMEOUT, null, null,
  1434.                 trustStore, crlStore, null, 
  1435.                 (HttpOptions[]) null);
  1436.         return res.getContent();
  1437.     }
  1438.     public static byte[] requestHTTPSFile(String path,
  1439.             KeyStore trustStore, IOCSPValidator ocspValidator) throws UtilsException{
  1440.         HttpResponse res = getHTTPSResponse(path, HTTP_READ_CONNECTION_TIMEOUT, HTTP_CONNECTION_TIMEOUT, null, null,
  1441.                 trustStore, null, ocspValidator, 
  1442.                 (HttpOptions[]) null);
  1443.         return res.getContent();
  1444.     }
  1445.     public static byte[] requestHTTPSFile(String path,
  1446.             KeyStore trustStore, CertStore crlStore, IOCSPValidator ocspValidator) throws UtilsException{
  1447.         HttpResponse res = getHTTPSResponse(path, HTTP_READ_CONNECTION_TIMEOUT, HTTP_CONNECTION_TIMEOUT, null, null,
  1448.                 trustStore, crlStore, ocspValidator, 
  1449.                 (HttpOptions[]) null);
  1450.         return res.getContent();
  1451.     }
  1452.     
  1453.     public static byte[] requestHTTPSFile(String path,int readTimeout,int connectTimeout,
  1454.             KeyStore trustStore) throws UtilsException{
  1455.         HttpResponse res = getHTTPSResponse(path, readTimeout, connectTimeout, null, null,
  1456.                 trustStore, null, null, 
  1457.                 (HttpOptions[]) null);
  1458.         return res.getContent();
  1459.     }
  1460.     public static byte[] requestHTTPSFile(String path,int readTimeout,int connectTimeout,
  1461.             KeyStore trustStore, CertStore crlStore) throws UtilsException{
  1462.         HttpResponse res = getHTTPSResponse(path, readTimeout, connectTimeout, null, null,
  1463.                 trustStore, crlStore, null, 
  1464.                 (HttpOptions[]) null);
  1465.         return res.getContent();
  1466.     }
  1467.     public static byte[] requestHTTPSFile(String path,int readTimeout,int connectTimeout,
  1468.             KeyStore trustStore, IOCSPValidator ocspValidator) throws UtilsException{
  1469.         HttpResponse res = getHTTPSResponse(path, readTimeout, connectTimeout, null, null,
  1470.                 trustStore, null, ocspValidator, 
  1471.                 (HttpOptions[]) null);
  1472.         return res.getContent();
  1473.     }
  1474.     public static byte[] requestHTTPSFile(String path,int readTimeout,int connectTimeout,
  1475.             KeyStore trustStore, CertStore crlStore, IOCSPValidator ocspValidator) throws UtilsException{
  1476.         HttpResponse res = getHTTPSResponse(path, readTimeout, connectTimeout, null, null,
  1477.                 trustStore, crlStore, ocspValidator, 
  1478.                 (HttpOptions[]) null);
  1479.         return res.getContent();
  1480.     }
  1481.     
  1482.     public static byte[] requestHTTPSFile(String path,String username,String password,
  1483.             KeyStore trustStore) throws UtilsException{
  1484.         HttpResponse res = getHTTPSResponse(path, HTTP_READ_CONNECTION_TIMEOUT, HTTP_CONNECTION_TIMEOUT, username, password,
  1485.                 trustStore, null, null, 
  1486.                 (HttpOptions[]) null);
  1487.         return res.getContent();
  1488.     }
  1489.     public static byte[] requestHTTPSFile(String path,String username,String password,
  1490.             KeyStore trustStore, CertStore crlStore) throws UtilsException{
  1491.         HttpResponse res = getHTTPSResponse(path, HTTP_READ_CONNECTION_TIMEOUT, HTTP_CONNECTION_TIMEOUT, username, password,
  1492.                 trustStore, crlStore, null, 
  1493.                 (HttpOptions[]) null);
  1494.         return res.getContent();
  1495.     }
  1496.     public static byte[] requestHTTPSFile(String path,String username,String password,
  1497.             KeyStore trustStore, IOCSPValidator ocspValidator) throws UtilsException{
  1498.         HttpResponse res = getHTTPSResponse(path, HTTP_READ_CONNECTION_TIMEOUT, HTTP_CONNECTION_TIMEOUT, username, password,
  1499.                 trustStore, null, ocspValidator, 
  1500.                 (HttpOptions[]) null);
  1501.         return res.getContent();
  1502.     }
  1503.     public static byte[] requestHTTPSFile(String path,String username,String password,
  1504.             KeyStore trustStore, CertStore crlStore, IOCSPValidator ocspValidator) throws UtilsException{
  1505.         HttpResponse res = getHTTPSResponse(path, HTTP_READ_CONNECTION_TIMEOUT, HTTP_CONNECTION_TIMEOUT, username, password,
  1506.                 trustStore, crlStore, ocspValidator, 
  1507.                 (HttpOptions[]) null);
  1508.         return res.getContent();
  1509.     }
  1510.     
  1511.     public static byte[] requestHTTPSFile(String path,int readTimeout,int connectTimeout,String username,String password,
  1512.             KeyStore trustStore) throws UtilsException{
  1513.         HttpResponse res = getHTTPSResponse(path, readTimeout, connectTimeout, username, password,
  1514.                 trustStore, null, null, 
  1515.                 (HttpOptions[]) null);
  1516.         return res.getContent();
  1517.     }
  1518.     public static byte[] requestHTTPSFile(String path,int readTimeout,int connectTimeout,String username,String password,
  1519.             KeyStore trustStore, CertStore crlStore) throws UtilsException{
  1520.         HttpResponse res = getHTTPSResponse(path, readTimeout, connectTimeout, username, password,
  1521.                 trustStore, crlStore, null, 
  1522.                 (HttpOptions[]) null);
  1523.         return res.getContent();
  1524.     }
  1525.     public static byte[] requestHTTPSFile(String path,int readTimeout,int connectTimeout,String username,String password,
  1526.             KeyStore trustStore, IOCSPValidator ocspValidator) throws UtilsException{
  1527.         HttpResponse res = getHTTPSResponse(path, readTimeout, connectTimeout, username, password,
  1528.                 trustStore, null, ocspValidator, 
  1529.                 (HttpOptions[]) null);
  1530.         return res.getContent();
  1531.     }
  1532.     public static byte[] requestHTTPSFile(String path,int readTimeout,int connectTimeout,String username,String password,
  1533.             KeyStore trustStore, CertStore crlStore, IOCSPValidator ocspValidator) throws UtilsException{
  1534.         HttpResponse res = getHTTPSResponse(path, readTimeout, connectTimeout, username, password,
  1535.                 trustStore, crlStore, ocspValidator, 
  1536.                 (HttpOptions[]) null);
  1537.         return res.getContent();
  1538.     }
  1539.     
  1540.     public static HttpResponse getHTTPSResponse(String path,
  1541.             KeyStore trustStore) throws UtilsException{
  1542.         return getHTTPSResponse(path, HTTP_READ_CONNECTION_TIMEOUT, HTTP_CONNECTION_TIMEOUT, null, null,
  1543.                 trustStore, null, null, 
  1544.                 (HttpOptions[]) null);
  1545.     }
  1546.     public static HttpResponse getHTTPSResponse(String path,
  1547.             KeyStore trustStore, CertStore crlStore) throws UtilsException{
  1548.         return getHTTPSResponse(path, HTTP_READ_CONNECTION_TIMEOUT, HTTP_CONNECTION_TIMEOUT, null, null,
  1549.                 trustStore, crlStore, null, 
  1550.                 (HttpOptions[]) null);
  1551.     }
  1552.     public static HttpResponse getHTTPSResponse(String path,
  1553.             KeyStore trustStore, IOCSPValidator ocspValidator) throws UtilsException{
  1554.         return getHTTPSResponse(path, HTTP_READ_CONNECTION_TIMEOUT, HTTP_CONNECTION_TIMEOUT, null, null,
  1555.                 trustStore, null, ocspValidator, 
  1556.                 (HttpOptions[]) null);
  1557.     }
  1558.     public static HttpResponse getHTTPSResponse(String path,
  1559.             KeyStore trustStore, CertStore crlStore, IOCSPValidator ocspValidator) throws UtilsException{
  1560.         return getHTTPSResponse(path, HTTP_READ_CONNECTION_TIMEOUT, HTTP_CONNECTION_TIMEOUT, null, null,
  1561.                 trustStore, crlStore, ocspValidator, 
  1562.                 (HttpOptions[]) null);
  1563.     }
  1564.     
  1565.     public static HttpResponse getHTTPSResponse(String path,int readTimeout,int connectTimeout,
  1566.             KeyStore trustStore) throws UtilsException{
  1567.         return getHTTPSResponse(path, readTimeout, connectTimeout, null, null,
  1568.                 trustStore, null, null, 
  1569.                 (HttpOptions[]) null);
  1570.     }
  1571.     public static HttpResponse getHTTPSResponse(String path,int readTimeout,int connectTimeout,
  1572.             KeyStore trustStore, CertStore crlStore) throws UtilsException{
  1573.         return getHTTPSResponse(path, readTimeout, connectTimeout, null, null,
  1574.                 trustStore, crlStore, null, 
  1575.                 (HttpOptions[]) null);
  1576.     }
  1577.     public static HttpResponse getHTTPSResponse(String path,int readTimeout,int connectTimeout,
  1578.             KeyStore trustStore, IOCSPValidator ocspValidator) throws UtilsException{
  1579.         return getHTTPSResponse(path, readTimeout, connectTimeout, null, null,
  1580.                 trustStore, null, ocspValidator, 
  1581.                 (HttpOptions[]) null);
  1582.     }
  1583.     public static HttpResponse getHTTPSResponse(String path,int readTimeout,int connectTimeout,
  1584.             KeyStore trustStore, CertStore crlStore, IOCSPValidator ocspValidator) throws UtilsException{
  1585.         return getHTTPSResponse(path, readTimeout, connectTimeout, null, null,
  1586.                 trustStore, crlStore, ocspValidator, 
  1587.                 (HttpOptions[]) null);
  1588.     }
  1589.     
  1590.     public static HttpResponse getHTTPSResponse(String path,String username,String password,
  1591.             KeyStore trustStore) throws UtilsException{
  1592.         return getHTTPSResponse(path, HTTP_READ_CONNECTION_TIMEOUT, HTTP_CONNECTION_TIMEOUT, username, password,
  1593.                 trustStore, null, null, 
  1594.                 (HttpOptions[]) null);
  1595.     }
  1596.     public static HttpResponse getHTTPSResponse(String path,String username,String password,
  1597.             KeyStore trustStore, CertStore crlStore) throws UtilsException{
  1598.         return getHTTPSResponse(path, HTTP_READ_CONNECTION_TIMEOUT, HTTP_CONNECTION_TIMEOUT, username, password,
  1599.                 trustStore, crlStore, null, 
  1600.                 (HttpOptions[]) null);
  1601.     }
  1602.     public static HttpResponse getHTTPSResponse(String path,String username,String password,
  1603.             KeyStore trustStore, IOCSPValidator ocspValidator) throws UtilsException{
  1604.         return getHTTPSResponse(path, HTTP_READ_CONNECTION_TIMEOUT, HTTP_CONNECTION_TIMEOUT, username, password,
  1605.                 trustStore, null, ocspValidator, 
  1606.                 (HttpOptions[]) null);
  1607.     }
  1608.     public static HttpResponse getHTTPSResponse(String path,String username,String password,
  1609.             KeyStore trustStore, CertStore crlStore, IOCSPValidator ocspValidator) throws UtilsException{
  1610.         return getHTTPSResponse(path, HTTP_READ_CONNECTION_TIMEOUT, HTTP_CONNECTION_TIMEOUT, username, password,
  1611.                 trustStore, crlStore, ocspValidator, 
  1612.                 (HttpOptions[]) null);
  1613.     }
  1614.     
  1615.     public static HttpResponse getHTTPSResponse(String path,int readTimeout,int connectTimeout,String username,String password,
  1616.             KeyStore trustStore) throws UtilsException{
  1617.         return getHTTPSResponse(path,readTimeout,connectTimeout,username,password,
  1618.                 trustStore, null, null, 
  1619.                 (HttpOptions[]) null);
  1620.     }
  1621.     public static HttpResponse getHTTPSResponse(String path,int readTimeout,int connectTimeout,String username,String password,
  1622.             KeyStore trustStore, CertStore crlStore) throws UtilsException{
  1623.         return getHTTPSResponse(path,readTimeout,connectTimeout,username,password,
  1624.                 trustStore, crlStore, null, 
  1625.                 (HttpOptions[]) null);
  1626.     }
  1627.     public static HttpResponse getHTTPSResponse(String path,int readTimeout,int connectTimeout,String username,String password,
  1628.             KeyStore trustStore, IOCSPValidator ocspValidator) throws UtilsException{
  1629.         return getHTTPSResponse(path,readTimeout,connectTimeout,username,password,
  1630.                 trustStore, null, ocspValidator, 
  1631.                 (HttpOptions[]) null);
  1632.     }
  1633.     public static HttpResponse getHTTPSResponse(String path,int readTimeout,int connectTimeout,String username,String password,
  1634.             KeyStore trustStore, CertStore crlStore, IOCSPValidator ocspValidator) throws UtilsException{
  1635.         return getHTTPSResponse(path,readTimeout,connectTimeout,username,password,
  1636.                 trustStore, crlStore, ocspValidator, 
  1637.                 (HttpOptions[]) null);
  1638.     }
  1639.     
  1640.     
  1641.     // getHTTPSResponse (options)
  1642.     
  1643.     public static byte[] requestHTTPSFile(String path,
  1644.             KeyStore trustStore,
  1645.             HttpOptions ... options) throws UtilsException{
  1646.         HttpResponse res = getHTTPSResponse(path, HTTP_READ_CONNECTION_TIMEOUT, HTTP_CONNECTION_TIMEOUT, null, null,
  1647.                 trustStore, null, null,
  1648.                 options);
  1649.         return res.getContent();
  1650.     }
  1651.     public static byte[] requestHTTPSFile(String path,
  1652.             KeyStore trustStore, CertStore crlStore,
  1653.             HttpOptions ... options) throws UtilsException{
  1654.         HttpResponse res = getHTTPSResponse(path, HTTP_READ_CONNECTION_TIMEOUT, HTTP_CONNECTION_TIMEOUT, null, null,
  1655.                 trustStore, crlStore, null,
  1656.                 options);
  1657.         return res.getContent();
  1658.     }
  1659.     public static byte[] requestHTTPSFile(String path,
  1660.             KeyStore trustStore, IOCSPValidator ocspValidator,
  1661.             HttpOptions ... options) throws UtilsException{
  1662.         HttpResponse res = getHTTPSResponse(path, HTTP_READ_CONNECTION_TIMEOUT, HTTP_CONNECTION_TIMEOUT, null, null,
  1663.                 trustStore, null, ocspValidator,
  1664.                 options);
  1665.         return res.getContent();
  1666.     }
  1667.     public static byte[] requestHTTPSFile(String path,
  1668.             KeyStore trustStore, CertStore crlStore, IOCSPValidator ocspValidator,
  1669.             HttpOptions ... options) throws UtilsException{
  1670.         HttpResponse res = getHTTPSResponse(path, HTTP_READ_CONNECTION_TIMEOUT, HTTP_CONNECTION_TIMEOUT, null, null,
  1671.                 trustStore, crlStore, ocspValidator,
  1672.                 options);
  1673.         return res.getContent();
  1674.     }
  1675.     
  1676.     public static byte[] requestHTTPSFile(String path,int readTimeout,int connectTimeout,
  1677.             KeyStore trustStore,
  1678.             HttpOptions ... options) throws UtilsException{
  1679.         HttpResponse res = getHTTPSResponse(path, readTimeout, connectTimeout, null, null,
  1680.                 trustStore, null, null,
  1681.                 options);
  1682.         return res.getContent();
  1683.     }
  1684.     public static byte[] requestHTTPSFile(String path,int readTimeout,int connectTimeout,
  1685.             KeyStore trustStore, CertStore crlStore,
  1686.             HttpOptions ... options) throws UtilsException{
  1687.         HttpResponse res = getHTTPSResponse(path, readTimeout, connectTimeout, null, null,
  1688.                 trustStore, crlStore, null,
  1689.                 options);
  1690.         return res.getContent();
  1691.     }
  1692.     public static byte[] requestHTTPSFile(String path,int readTimeout,int connectTimeout,
  1693.             KeyStore trustStore, IOCSPValidator ocspValidator,
  1694.             HttpOptions ... options) throws UtilsException{
  1695.         HttpResponse res = getHTTPSResponse(path, readTimeout, connectTimeout, null, null,
  1696.                 trustStore, null, ocspValidator,
  1697.                 options);
  1698.         return res.getContent();
  1699.     }
  1700.     public static byte[] requestHTTPSFile(String path,int readTimeout,int connectTimeout,
  1701.             KeyStore trustStore, CertStore crlStore, IOCSPValidator ocspValidator,
  1702.             HttpOptions ... options) throws UtilsException{
  1703.         HttpResponse res = getHTTPSResponse(path, readTimeout, connectTimeout, null, null,
  1704.                 trustStore, crlStore, ocspValidator,
  1705.                 options);
  1706.         return res.getContent();
  1707.     }
  1708.     
  1709.     public static byte[] requestHTTPSFile(String path,String username,String password,
  1710.             KeyStore trustStore,
  1711.             HttpOptions ... options) throws UtilsException{
  1712.         HttpResponse res = getHTTPSResponse(path, HTTP_READ_CONNECTION_TIMEOUT, HTTP_CONNECTION_TIMEOUT, username, password,
  1713.                 trustStore, null, null,
  1714.                 options);
  1715.         return res.getContent();
  1716.     }
  1717.     public static byte[] requestHTTPSFile(String path,String username,String password,
  1718.             KeyStore trustStore, CertStore crlStore,
  1719.             HttpOptions ... options) throws UtilsException{
  1720.         HttpResponse res = getHTTPSResponse(path, HTTP_READ_CONNECTION_TIMEOUT, HTTP_CONNECTION_TIMEOUT, username, password,
  1721.                 trustStore, crlStore, null,
  1722.                 options);
  1723.         return res.getContent();
  1724.     }
  1725.     public static byte[] requestHTTPSFile(String path,String username,String password,
  1726.             KeyStore trustStore, IOCSPValidator ocspValidator,
  1727.             HttpOptions ... options) throws UtilsException{
  1728.         HttpResponse res = getHTTPSResponse(path, HTTP_READ_CONNECTION_TIMEOUT, HTTP_CONNECTION_TIMEOUT, username, password,
  1729.                 trustStore, null, ocspValidator,
  1730.                 options);
  1731.         return res.getContent();
  1732.     }
  1733.     public static byte[] requestHTTPSFile(String path,String username,String password,
  1734.             KeyStore trustStore, CertStore crlStore, IOCSPValidator ocspValidator,
  1735.             HttpOptions ... options) throws UtilsException{
  1736.         HttpResponse res = getHTTPSResponse(path, HTTP_READ_CONNECTION_TIMEOUT, HTTP_CONNECTION_TIMEOUT, username, password,
  1737.                 trustStore, crlStore, ocspValidator,
  1738.                 options);
  1739.         return res.getContent();
  1740.     }
  1741.     
  1742.     public static byte[] requestHTTPSFile(String path,int readTimeout,int connectTimeout,String username,String password,
  1743.             KeyStore trustStore,
  1744.             HttpOptions ... options) throws UtilsException{
  1745.         HttpResponse res = getHTTPSResponse(path, readTimeout, connectTimeout, username, password,
  1746.                 trustStore, null, null,
  1747.                 options);
  1748.         return res.getContent();
  1749.     }
  1750.     public static byte[] requestHTTPSFile(String path,int readTimeout,int connectTimeout,String username,String password,
  1751.             KeyStore trustStore, CertStore crlStore,
  1752.             HttpOptions ... options) throws UtilsException{
  1753.         HttpResponse res = getHTTPSResponse(path, readTimeout, connectTimeout, username, password,
  1754.                 trustStore, crlStore, null,
  1755.                 options);
  1756.         return res.getContent();
  1757.     }
  1758.     public static byte[] requestHTTPSFile(String path,int readTimeout,int connectTimeout,String username,String password,
  1759.             KeyStore trustStore, IOCSPValidator ocspValidator,
  1760.             HttpOptions ... options) throws UtilsException{
  1761.         HttpResponse res = getHTTPSResponse(path, readTimeout, connectTimeout, username, password,
  1762.                 trustStore, null, ocspValidator,
  1763.                 options);
  1764.         return res.getContent();
  1765.     }
  1766.     public static byte[] requestHTTPSFile(String path,int readTimeout,int connectTimeout,String username,String password,
  1767.             KeyStore trustStore, CertStore crlStore, IOCSPValidator ocspValidator,
  1768.             HttpOptions ... options) throws UtilsException{
  1769.         HttpResponse res = getHTTPSResponse(path, readTimeout, connectTimeout, username, password,
  1770.                 trustStore, crlStore, ocspValidator,
  1771.                 options);
  1772.         return res.getContent();
  1773.     }
  1774.     
  1775.     public static HttpResponse getHTTPSResponse(String path,
  1776.             KeyStore trustStore,
  1777.             HttpOptions ... options) throws UtilsException{
  1778.         return getHTTPSResponse(path, HTTP_READ_CONNECTION_TIMEOUT, HTTP_CONNECTION_TIMEOUT, null, null,
  1779.                 trustStore, null, null,
  1780.                 options);
  1781.     }
  1782.     public static HttpResponse getHTTPSResponse(String path,
  1783.             KeyStore trustStore, CertStore crlStore,
  1784.             HttpOptions ... options) throws UtilsException{
  1785.         return getHTTPSResponse(path, HTTP_READ_CONNECTION_TIMEOUT, HTTP_CONNECTION_TIMEOUT, null, null,
  1786.                 trustStore, crlStore, null,
  1787.                 options);
  1788.     }
  1789.     public static HttpResponse getHTTPSResponse(String path,
  1790.             KeyStore trustStore, IOCSPValidator ocspValidator,
  1791.             HttpOptions ... options) throws UtilsException{
  1792.         return getHTTPSResponse(path, HTTP_READ_CONNECTION_TIMEOUT, HTTP_CONNECTION_TIMEOUT, null, null,
  1793.                 trustStore, null, ocspValidator,
  1794.                 options);
  1795.     }
  1796.     public static HttpResponse getHTTPSResponse(String path,
  1797.             KeyStore trustStore, CertStore crlStore, IOCSPValidator ocspValidator,
  1798.             HttpOptions ... options) throws UtilsException{
  1799.         return getHTTPSResponse(path, HTTP_READ_CONNECTION_TIMEOUT, HTTP_CONNECTION_TIMEOUT, null, null,
  1800.                 trustStore, crlStore, ocspValidator,
  1801.                 options);
  1802.     }
  1803.     
  1804.     public static HttpResponse getHTTPSResponse(String path,int readTimeout,int connectTimeout,
  1805.             KeyStore trustStore,
  1806.             HttpOptions ... options) throws UtilsException{
  1807.         return getHTTPSResponse(path, readTimeout, connectTimeout, null, null,
  1808.                 trustStore, null, null,
  1809.                 options);
  1810.     }
  1811.     public static HttpResponse getHTTPSResponse(String path,int readTimeout,int connectTimeout,
  1812.             KeyStore trustStore, CertStore crlStore,
  1813.             HttpOptions ... options) throws UtilsException{
  1814.         return getHTTPSResponse(path, readTimeout, connectTimeout, null, null,
  1815.                 trustStore, crlStore, null,
  1816.                 options);
  1817.     }
  1818.     public static HttpResponse getHTTPSResponse(String path,int readTimeout,int connectTimeout,
  1819.             KeyStore trustStore, IOCSPValidator ocspValidator,
  1820.             HttpOptions ... options) throws UtilsException{
  1821.         return getHTTPSResponse(path, readTimeout, connectTimeout, null, null,
  1822.                 trustStore, null, ocspValidator,
  1823.                 options);
  1824.     }
  1825.     public static HttpResponse getHTTPSResponse(String path,int readTimeout,int connectTimeout,
  1826.             KeyStore trustStore, CertStore crlStore, IOCSPValidator ocspValidator,
  1827.             HttpOptions ... options) throws UtilsException{
  1828.         return getHTTPSResponse(path, readTimeout, connectTimeout, null, null,
  1829.                 trustStore, crlStore, ocspValidator,
  1830.                 options);
  1831.     }
  1832.     
  1833.     public static HttpResponse getHTTPSResponse(String path,String username,String password,
  1834.             KeyStore trustStore,
  1835.             HttpOptions ... options) throws UtilsException{
  1836.         return getHTTPSResponse(path, HTTP_READ_CONNECTION_TIMEOUT, HTTP_CONNECTION_TIMEOUT, username, password,
  1837.                 trustStore, null, null,
  1838.                 options);
  1839.     }
  1840.     public static HttpResponse getHTTPSResponse(String path,String username,String password,
  1841.             KeyStore trustStore, CertStore crlStore,
  1842.             HttpOptions ... options) throws UtilsException{
  1843.         return getHTTPSResponse(path, HTTP_READ_CONNECTION_TIMEOUT, HTTP_CONNECTION_TIMEOUT, username, password,
  1844.                 trustStore, crlStore, null,
  1845.                 options);
  1846.     }
  1847.     public static HttpResponse getHTTPSResponse(String path,String username,String password,
  1848.             KeyStore trustStore, IOCSPValidator ocspValidator,
  1849.             HttpOptions ... options) throws UtilsException{
  1850.         return getHTTPSResponse(path, HTTP_READ_CONNECTION_TIMEOUT, HTTP_CONNECTION_TIMEOUT, username, password,
  1851.                 trustStore, null, ocspValidator,
  1852.                 options);
  1853.     }
  1854.     public static HttpResponse getHTTPSResponse(String path,String username,String password,
  1855.             KeyStore trustStore, CertStore crlStore, IOCSPValidator ocspValidator,
  1856.             HttpOptions ... options) throws UtilsException{
  1857.         return getHTTPSResponse(path, HTTP_READ_CONNECTION_TIMEOUT, HTTP_CONNECTION_TIMEOUT, username, password,
  1858.                 trustStore, crlStore, ocspValidator,
  1859.                 options);
  1860.     }
  1861.     
  1862.     public static HttpResponse getHTTPSResponse(String path,int readTimeout,int connectTimeout,String username,String password,
  1863.             KeyStore trustStore,
  1864.             HttpOptions ... options) throws UtilsException{
  1865.         return getHTTPSResponse(path,readTimeout,connectTimeout,username,password,
  1866.                 trustStore, null, null,
  1867.                 options);
  1868.     }
  1869.     public static HttpResponse getHTTPSResponse(String path,int readTimeout,int connectTimeout,String username,String password,
  1870.             KeyStore trustStore, CertStore crlStore,
  1871.             HttpOptions ... options) throws UtilsException{
  1872.         return getHTTPSResponse(path,readTimeout,connectTimeout,username,password,
  1873.                 trustStore, crlStore, null,
  1874.                 options);
  1875.     }
  1876.     public static HttpResponse getHTTPSResponse(String path,int readTimeout,int connectTimeout,String username,String password,
  1877.             KeyStore trustStore, IOCSPValidator ocspValidator,
  1878.             HttpOptions ... options) throws UtilsException{
  1879.         return getHTTPSResponse(path,readTimeout,connectTimeout,username,password,
  1880.                 trustStore, null, ocspValidator,
  1881.                 options);
  1882.     }
  1883.         
  1884.     public static HttpResponse getHTTPSResponse(String path,int readTimeout,int connectTimeout,String username,String password,
  1885.             KeyStore trustStore, CertStore crlStore, IOCSPValidator ocspValidator,
  1886.             HttpOptions ... options) throws UtilsException{
  1887.         
  1888.         HttpRequest httpRequest = new HttpRequest();
  1889.         httpRequest.setUrl(path);
  1890.         httpRequest.setReadTimeout(readTimeout);
  1891.         httpRequest.setConnectTimeout(connectTimeout);
  1892.         httpRequest.setUsername(username);
  1893.         httpRequest.setPassword(password);
  1894.         httpRequest.setMethod(HttpRequestMethod.GET);
  1895.         
  1896.         httpRequest.setTrustStore(trustStore);
  1897.         httpRequest.setCrlStore(crlStore);
  1898.         httpRequest.setOcspValidator(ocspValidator);
  1899.         
  1900.         if(options!=null && options.length>0) {
  1901.             for (HttpOptions httpOptions : options) {
  1902.                 httpOptions.fill(httpRequest);
  1903.             }
  1904.         }
  1905.         
  1906.         HttpResponse response = null;
  1907.         try{
  1908.             response = httpInvoke(httpRequest);
  1909.             
  1910.         }catch(Exception e){
  1911.             throw new UtilsException("Utilities.requestHTTPFile error "+e.getMessage(),e);
  1912.         }
  1913.         if(response.getResultHTTPOperation()==404){
  1914.             throw new UtilsException("404");
  1915.         }
  1916.         return response;
  1917.         
  1918.     }
  1919.     
  1920.     
  1921.     
  1922.     
  1923.     // getHTTPSResponse_trustAllCerts (no options)
  1924.     
  1925.     public static byte[] requestHTTPSFile_trustAllCerts(String path) throws UtilsException{
  1926.         return requestHTTPSFile_trustAllCerts(path, HTTP_READ_CONNECTION_TIMEOUT, HTTP_CONNECTION_TIMEOUT, null, null, 
  1927.                 (HttpOptions[]) null);
  1928.     }
  1929.     
  1930.     public static byte[] requestHTTPSFile_trustAllCerts(String path,int readTimeout,int connectTimeout) throws UtilsException{
  1931.         return requestHTTPSFile_trustAllCerts(path, readTimeout, connectTimeout, null, null, 
  1932.                 (HttpOptions[]) null);
  1933.     }
  1934.     
  1935.     public static byte[] requestHTTPSFile_trustAllCerts(String path,String username,String password) throws UtilsException{
  1936.         return requestHTTPSFile_trustAllCerts(path, HTTP_READ_CONNECTION_TIMEOUT, HTTP_CONNECTION_TIMEOUT, username, password, 
  1937.                 (HttpOptions[]) null);
  1938.     }

  1940.     public static byte[] requestHTTPSFile_trustAllCerts(String path,int readTimeout,int connectTimeout,String username,String password) throws UtilsException{
  1941.         HttpResponse res = getHTTPSResponse_trustAllCerts(path, readTimeout, connectTimeout, username, password, 
  1942.                 (HttpOptions[]) null);
  1943.         return res.getContent();
  1944.     }
  1945.     
  1946.     public static HttpResponse getHTTPSResponse_trustAllCerts(String path) throws UtilsException{
  1947.         return getHTTPSResponse_trustAllCerts(path, HTTP_READ_CONNECTION_TIMEOUT, HTTP_CONNECTION_TIMEOUT, null, null, 
  1948.                 (HttpOptions[]) null);
  1949.     }
  1950.     
  1951.     public static HttpResponse getHTTPSResponse_trustAllCerts(String path,int readTimeout,int connectTimeout) throws UtilsException{
  1952.         return getHTTPSResponse_trustAllCerts(path, readTimeout, connectTimeout, null, null, 
  1953.                 (HttpOptions[]) null);
  1954.     }
  1955.     
  1956.     public static HttpResponse getHTTPSResponse_trustAllCerts(String path,String username,String password) throws UtilsException{
  1957.         return getHTTPSResponse_trustAllCerts(path, HTTP_READ_CONNECTION_TIMEOUT, HTTP_CONNECTION_TIMEOUT, username, password, 
  1958.                 (HttpOptions[]) null);
  1959.     }   
  1960.     
  1961.     public static HttpResponse getHTTPSResponse_trustAllCerts(String path,int readTimeout,int connectTimeout,String username,String password) throws UtilsException{
  1962.         return getHTTPSResponse_trustAllCerts(path, readTimeout, connectTimeout, username, password, 
  1963.                 (HttpOptions[]) null);
  1964.     }
  1965.     
  1966.     
  1967.     // getHTTPSResponse_trustAllCerts (options)
  1968.     
  1969.     public static byte[] requestHTTPSFile_trustAllCerts(String path,
  1970.             HttpOptions ... options) throws UtilsException{
  1971.         return requestHTTPSFile_trustAllCerts(path, HTTP_READ_CONNECTION_TIMEOUT, HTTP_CONNECTION_TIMEOUT, null, null,
  1972.                 options);
  1973.     }
  1974.     
  1975.     public static byte[] requestHTTPSFile_trustAllCerts(String path,int readTimeout,int connectTimeout,
  1976.             HttpOptions ... options) throws UtilsException{
  1977.         return requestHTTPSFile_trustAllCerts(path, readTimeout, connectTimeout, null, null,
  1978.                 options);
  1979.     }
  1980.     
  1981.     public static byte[] requestHTTPSFile_trustAllCerts(String path,String username,String password,
  1982.             HttpOptions ... options) throws UtilsException{
  1983.         return requestHTTPSFile_trustAllCerts(path, HTTP_READ_CONNECTION_TIMEOUT, HTTP_CONNECTION_TIMEOUT, username, password,
  1984.                 options);
  1985.     }

  1987.     public static byte[] requestHTTPSFile_trustAllCerts(String path,int readTimeout,int connectTimeout,String username,String password,
  1988.             HttpOptions ... options) throws UtilsException{
  1989.         HttpResponse res = getHTTPSResponse_trustAllCerts(path, readTimeout, connectTimeout, username, password,
  1990.                 options);
  1991.         return res.getContent();
  1992.     }
  1993.     
  1994.     public static HttpResponse getHTTPSResponse_trustAllCerts(String path,
  1995.             HttpOptions ... options) throws UtilsException{
  1996.         return getHTTPSResponse_trustAllCerts(path, HTTP_READ_CONNECTION_TIMEOUT, HTTP_CONNECTION_TIMEOUT, null, null,
  1997.                 options);
  1998.     }
  1999.     
  2000.     public static HttpResponse getHTTPSResponse_trustAllCerts(String path,int readTimeout,int connectTimeout,
  2001.             HttpOptions ... options) throws UtilsException{
  2002.         return getHTTPSResponse_trustAllCerts(path, readTimeout, connectTimeout, null, null,
  2003.                 options);
  2004.     }
  2005.     
  2006.     public static HttpResponse getHTTPSResponse_trustAllCerts(String path,String username,String password,
  2007.             HttpOptions ... options) throws UtilsException{
  2008.         return getHTTPSResponse_trustAllCerts(path, HTTP_READ_CONNECTION_TIMEOUT, HTTP_CONNECTION_TIMEOUT, username, password,
  2009.                 options);
  2010.     }   
  2011.     
  2012.     public static HttpResponse getHTTPSResponse_trustAllCerts(String path,int readTimeout,int connectTimeout,String username,String password,
  2013.             HttpOptions ... options) throws UtilsException{
  2014.         
  2015.         HttpRequest httpRequest = new HttpRequest();
  2016.         httpRequest.setUrl(path);
  2017.         httpRequest.setReadTimeout(readTimeout);
  2018.         httpRequest.setConnectTimeout(connectTimeout);
  2019.         httpRequest.setUsername(username);
  2020.         httpRequest.setPassword(password);
  2021.         httpRequest.setMethod(HttpRequestMethod.GET);
  2022.         
  2023.         httpRequest.setTrustAllCerts(true);
  2024.         
  2025.         if(options!=null && options.length>0) {
  2026.             for (HttpOptions httpOptions : options) {
  2027.                 httpOptions.fill(httpRequest);
  2028.             }
  2029.         }
  2030.         
  2031.         HttpResponse response = null;
  2032.         try{
  2033.             response = httpInvoke(httpRequest);
  2034.             
  2035.         }catch(Exception e){
  2036.             throw new UtilsException("Utilities.requestHTTPFile error "+e.getMessage(),e);
  2037.         }
  2038.         if(response.getResultHTTPOperation()==404){
  2039.             throw new UtilsException("404");
  2040.         }
  2041.         return response;
  2042.         
  2043.     }
  2044.     
  2045.     private static final String TEST_FILE_ORIGIN = "file://";
  2046.     
  2047.     public static HttpResponse httpInvoke(HttpRequest request) throws UtilsException{
  2048.         
  2049.         String path = request.getUrl();
  2050.         if(path!=null && path.startsWith(TEST_FILE_ORIGIN)){
  2051.             String filePath = path.substring(TEST_FILE_ORIGIN.length());
  2052.             File f = new File(filePath);
  2053.             if(!f.exists()){
  2054.                 throw new UtilsException("404");
  2055.             }
  2056.             if(!f.canRead()){
  2057.                 throw new UtilsException("404");
  2058.             }
  2059.             HttpResponse response = new HttpResponse();
  2060.             try{
  2061.                 response.setContent(FileSystemUtilities.readBytesFromFile(f));
  2062.             }catch(Exception e){
  2063.                 throw new UtilsException(e.getMessage(),e);
  2064.             }
  2065.             response.setResultHTTPOperation(200);
  2066.             response.setContentType(MimeTypes.getInstance().getMimeType(f));
  2067.             return response;
  2068.         }
  2069.         
  2070.         
  2071.         InputStream is = null;
  2072.         ByteArrayOutputStream outResponse = null;
  2073.         InputStream finKeyStore = null;
  2074.         InputStream finTrustStore = null;
  2075.         try {
  2076.             SSLContext sslContext = null;
  2077.             OCSPTrustManager ocspTrustManager = null;
  2078.             
  2079.             if(request.isTrustAllCerts() || request.getTrustStore()!=null || request.getTrustStorePath()!=null){
  2080.                 
  2081.                 KeyManager[] km = null;
  2082.                 TrustManager[] tm = null;
  2083.                                 
  2084.                 // Autenticazione CLIENT
  2085.                 if(request.getKeyStore()!=null || request.getKeyStorePath()!=null){
  2086.                     String location = null;
  2087.                     try {
  2088.                         location = request.getKeyStorePath(); // per debug
  2089.                     
  2090.                         boolean hsmKeystore = false;
  2091.                         HSMManager hsmManager = HSMManager.getInstance();
  2092.                         String hsmType = null;
  2093.                         if(hsmManager!=null) {
  2094.                             if(request.getKeyStore()!=null) {
  2095.                                 hsmType = request.getKeyStore().getType();
  2096.                             }
  2097.                             else {
  2098.                                 hsmType = request.getKeyStoreType();
  2099.                             }
  2100.                             if(hsmType!=null) {
  2101.                                 hsmKeystore = hsmManager.existsKeystoreType(hsmType);
  2102.                                 if(!hsmKeystore) {
  2103.                                     hsmType = null;
  2104.                                 }
  2105.                             }
  2106.                         }
  2107.                         
  2108.                         KeyStore keystore = null;
  2109.                         KeyStore keystoreParam = null;
  2110.                         @SuppressWarnings("unused")
  2111.                         Provider keystoreProvider = null;
  2112.                         if(request.getKeyStore()!=null) {
  2113.                             keystoreParam = request.getKeyStore();
  2114.                             if(hsmKeystore) {
  2115.                                 keystoreProvider = keystoreParam.getProvider();
  2116.                             }
  2117.                         }
  2118.                         else {
  2119.                             if(hsmKeystore) {
  2120.                                 org.openspcoop2.utils.certificate.KeyStore ks = hsmManager.getKeystore(hsmType);
  2121.                                 if(ks==null) {
  2122.                                     throw new UtilsException("Keystore not found");
  2123.                                 }
  2124.                                 keystoreParam = ks.getKeystore();
  2125.                                 keystoreProvider = keystoreParam.getProvider();
  2126.                             }
  2127.                             else {
  2128.                                 File file = new File(location);
  2129.                                 if(file.exists()) {
  2130.                                     finKeyStore = new FileInputStream(file);
  2131.                                 }
  2132.                                 else {
  2133.                                     finKeyStore = SSLUtilities.class.getResourceAsStream(location);
  2134.                                 }
  2135.                                 if(finKeyStore == null) {
  2136.                                     throw new UtilsException("Keystore not found");
  2137.                                 }
  2138.                                 String tipo = request.getKeyStoreType()!=null ? request.getKeyStoreType() : KeystoreType.JKS.getNome();
  2139.                                 keystoreParam = KeystoreUtils.readKeystore(finKeyStore, tipo, request.getKeyStorePassword());
  2140.                             }
  2141.                         }
  2142.                         
  2143.                         boolean oldMethodKeyAlias = false; // Questo metodo non funzirequestonava con PKCS11
  2144.                         if(oldMethodKeyAlias && request.getKeyAlias()!=null) {
  2145.                             Key key = keystoreParam.getKey(request.getKeyAlias(), request.getKeyPassword().toCharArray());
  2146.                             if(key==null) {
  2147.                                 throw new UtilsException("Key with alias '"+request.getKeyAlias()+"' not found");
  2148.                             }
  2149.                             if(hsmKeystore) {
  2150.                                 // uso un JKS come tmp
  2151.                                 keystore = KeyStore.getInstance(KeystoreType.JKS.getNome());
  2152.                             }
  2153.                             else {
  2154.                                 keystore = KeyStore.getInstance(request.getKeyStoreType());
  2155.                             }
  2156.                             keystore.load(null); // inizializza il keystore
  2157.                             keystore.setKeyEntry(request.getKeyAlias(), key, 
  2158.                                     request.getKeyPassword().toCharArray()!=null ? request.getKeyPassword().toCharArray() : "".toCharArray(), 
  2159.                                     keystoreParam.getCertificateChain(request.getKeyAlias()));
  2160.                         }
  2161.                         else {
  2162.                             keystore = keystoreParam;
  2163.                         }
  2164.                         
  2165.                         KeyManagerFactory keyManagerFactory = null;
  2166.                         // NO: no such algorithm: SunX509 for provider SunPKCS11-xxx
  2167.                         /**if(keystoreProvider!=null) {
  2168.                         //  keyManagerFactory = KeyManagerFactory.getInstance(sslConfig.getKeyManagementAlgorithm(), keystoreProvider);
  2169.                         //}
  2170.                         //else {*/
  2171.                         keyManagerFactory = KeyManagerFactory.getInstance("SunX509");
  2172.                         
  2173.                         keyManagerFactory.init(keystore, request.getKeyPassword().toCharArray()!=null ? request.getKeyPassword().toCharArray() : "".toCharArray());
  2174.                         km = keyManagerFactory.getKeyManagers();
  2175.                         if(!oldMethodKeyAlias && request.getKeyAlias()!=null &&
  2176.                             km!=null && km.length>0 && km[0]!=null && km[0] instanceof X509KeyManager) {
  2177.                                 
  2178.                             String alias = request.getKeyAlias();
  2179.                             
  2180.                             // Fix case insensitive
  2181.                             Enumeration<String> enAliases = keystore.aliases();
  2182.                             if(enAliases!=null) {
  2183.                                 while (enAliases.hasMoreElements()) {
  2184.                                     String a = enAliases.nextElement();
  2185.                                     if(a.equalsIgnoreCase(alias)) {
  2186.                                         alias = a; // uso quello presente nel keystore
  2187.                                         break;
  2188.                                     }
  2189.                                 }
  2190.                             }
  2191.                             
  2192.                             X509KeyManager wrapperX509KeyManager = new SSLX509ManagerForcedClientAlias(alias, (X509KeyManager)km[0] );
  2193.                             km[0] = wrapperX509KeyManager;
  2194.                             
  2195.                         }
  2196.                     }catch(Throwable e) {
  2197.                         if(location!=null) {
  2198.                             throw new UtilsException("["+location+"] "+e.getMessage(),e);
  2199.                         }
  2200.                         else {
  2201.                             throw new UtilsException(e.getMessage(),e);
  2202.                         }
  2203.                     }
  2204.                 }
  2205.                 
  2206.                 // Autenticazione Server
  2207.                 KeyStore truststore = null;
  2208.                 if(request.isTrustAllCerts()) {
  2209.                     tm = SSLUtilities.getTrustAllCertsManager();
  2210.                 }
  2211.                 else {
  2212.                     
  2213.                     boolean hsmTruststore = false;
  2214.                     HSMManager hsmManager = HSMManager.getInstance();
  2215.                     if(hsmManager!=null) {
  2216.                         if(request.getTrustStore()!=null) {
  2217.                             hsmTruststore = request.isTrustStoreHsm();
  2218.                         }
  2219.                         else {
  2220.                             if(request.getTrustStoreType()!=null && hsmManager.existsKeystoreType(request.getTrustStoreType())) {
  2221.                                 hsmTruststore = true;           
  2222.                             }
  2223.                         }
  2224.                     }
  2225.                     
  2226.                     @SuppressWarnings("unused")
  2227.                     Provider truststoreProvider = null;
  2228.                     if(request.getTrustStore()!=null ) {
  2229.                         truststore = request.getTrustStore();
  2230.                         if(hsmTruststore) {
  2231.                             truststoreProvider = truststore.getProvider();
  2232.                         }
  2233.                     }
  2234.                     else {
  2235.                         if(request.getTrustStoreType()==null) {
  2236.                             throw new UtilsException("Ssl TrustStore type required");
  2237.                         }
  2238.                         if(request.getTrustStorePassword()==null) {
  2239.                             throw new UtilsException("Ssl TrustStore password required");
  2240.                         }
  2241.                         if(hsmTruststore) {
  2242.                             org.openspcoop2.utils.certificate.KeyStore ks = hsmManager.getKeystore(request.getTrustStoreType());
  2243.                             if(ks==null) {
  2244.                                 throw new UtilsException("Keystore not found");
  2245.                             }
  2246.                             truststore = ks.getKeystore();
  2247.                             truststoreProvider = truststore.getProvider();
  2248.                         }
  2249.                         else {
  2250.                             File file = new File(request.getTrustStorePath());
  2251.                             if(file.exists()) {
  2252.                                 finTrustStore = new FileInputStream(file);
  2253.                             }
  2254.                             else {
  2255.                                 finTrustStore = SSLUtilities.class.getResourceAsStream(request.getTrustStorePath());
  2256.                             }
  2257.                             if(finTrustStore == null) {
  2258.                                 throw new UtilsException("Keystore ["+request.getTrustStorePath()+"] not found");
  2259.                             }
  2260.                             truststore = KeystoreUtils.readKeystore(finTrustStore, request.getTrustStoreType(), request.getTrustStorePassword());
  2261.                         }
  2262.                     }
  2263.                                         
  2264.                     TrustManagerFactory trustManagerFactory = null;
  2265.                     // NO: no such algorithm: PKIX for provider SunPKCS11-xxx
  2266.                     /**if(truststoreProvider!=null) {
  2267.                     //  trustManagerFactory = TrustManagerFactory.getInstance("PKIX", truststoreProvider);
  2268.                     //}
  2269.                     //else {*/
  2270.                     trustManagerFactory = TrustManagerFactory.getInstance("PKIX");
  2271.                     
  2272.                     Provider sigProvider = null;                    
  2273.                     CertPathTrustManagerParameters params = SSLUtilities.buildCertPathTrustManagerParameters(truststore, request.getCrlStore(), request.getCrlPath(), sigProvider);
  2274.                     trustManagerFactory.init(params);
  2275.                     tm = trustManagerFactory.getTrustManagers();
  2276.                 }

  2278.                 IOCSPValidator ocspValidator = request.getOcspValidator();
  2279.                 if(truststore!=null && ocspValidator==null && request.getOcspPolicy()!=null && StringUtils.isNotEmpty(request.getOcspPolicy())) {
  2280.                     Logger log = LoggerWrapperFactory.getLogger(HttpUtilities.class);
  2281.                     IOCSPValidatorBuilder builder = (IOCSPValidatorBuilder) new Loader().newInstance("org.openspcoop2.utils.certificate.ocsp.OCSPValidatorBuilderImpl");
  2282.                     ocspValidator = builder.newInstance(log, truststore, request.getCrlPath(), request.getOcspPolicy());
  2283.                 }
  2284.                 if(ocspValidator!=null) {
  2285.                     tm = OCSPTrustManager.wrap(tm, ocspValidator);
  2286.                     ocspTrustManager = OCSPTrustManager.read(tm);
  2287.                     ocspValidator.setOCSPTrustManager(ocspTrustManager);
  2288.                 }

  2290.                 
  2291.                 sslContext = SSLContext.getInstance(SSLUtilities.getSafeDefaultProtocol()); // ritorna l'ultima versione disponibile
  2292.                 
  2293.                 if(request.isSecureRandom()) {
  2294.                     RandomGenerator randomGenerator = null;
  2295.                     if(request.getSecureRandomAlgorithm()!=null && !"".equals(request.getSecureRandomAlgorithm())) {
  2296.                         randomGenerator = new RandomGenerator(true, request.getSecureRandomAlgorithm());
  2297.                     }
  2298.                     else {
  2299.                         randomGenerator = new RandomGenerator(true);
  2300.                     }
  2301.                     java.security.SecureRandom secureRandom = (java.security.SecureRandom) randomGenerator.getRandomEngine();
  2302.                     sslContext.init(km, tm, secureRandom);
  2303.                 }
  2304.                 else {
  2305.                     sslContext.init(km, tm, null);
  2306.                 }
  2307.             }
  2308.             
  2309.             if(request.getUrl()==null){
  2310.                 throw new UtilsException("Url required");
  2311.             }
  2312.             String connectionUrl = request.getUrl();
  2313.             if(request.getForwardProxyEndpoint()!=null && request.getForwardProxyConfig()!=null) {
  2314.                 Map<String, List<String>> parameters = new HashMap<>();
  2315.                 if(request.getForwardProxyConfig().getQuery()!=null) {
  2316.                     if(request.getForwardProxyConfig().isQueryBase64()) {
  2317.                         String base64Location = Base64Utilities.encodeAsString(connectionUrl.getBytes());
  2318.                         TransportUtils.addParameter(parameters,request.getForwardProxyConfig().getQuery(), base64Location);
  2319.                     }
  2320.                     else {
  2321.                         TransportUtils.addParameter(parameters,request.getForwardProxyConfig().getQuery(), connectionUrl);
  2322.                     }
  2323.                 }
  2324.                 else if(request.getForwardProxyConfig().getHeader()!=null) {
  2325.                     if(request.getForwardProxyConfig().isHeaderBase64()) {
  2326.                         String base64Location = Base64Utilities.encodeAsString(connectionUrl.getBytes());
  2327.                         request.addHeader(request.getForwardProxyConfig().getHeader(), base64Location);
  2328.                     }
  2329.                     else {
  2330.                         request.addHeader(request.getForwardProxyConfig().getHeader(), connectionUrl);
  2331.                     }
  2332.                 }
  2333.                 boolean encodeBaseLocation = true; // la base location può contenere dei parametri
  2334.                 connectionUrl = TransportUtils.buildUrlWithParameters(parameters, request.getForwardProxyEndpoint(), encodeBaseLocation, LoggerWrapperFactory.getLogger(HttpUtilities.class));
  2335.             }
  2336.             URL url = new URL(connectionUrl);
  2337.             URLConnection connection = null;
  2338.             if(request.getProxyType()==null){
  2339.                 connection = url.openConnection();
  2340.             }
  2341.             else {
  2342.                 if(request.getProxyHostname()==null) {
  2343.                     throw new UtilsException("Proxy require a hostname");
  2344.                 }
  2345.                 Proxy proxy = new Proxy(request.getProxyType(), new InetSocketAddress(request.getProxyHostname(), request.getProxyPort()));
  2346.                 connection = url.openConnection(proxy);
  2347.                 
  2348.                 // Proxy Authentication BASIC
  2349.                 if(request.getProxyUsername()!=null && request.getProxyPassword()!=null){
  2350.                     String authentication = request.getProxyUsername() + ":" + request.getProxyPassword();
  2351.                     authentication = HttpConstants.AUTHORIZATION_PREFIX_BASIC + Base64Utilities.encodeAsString(authentication.getBytes());
  2352.                     request.addHeader(HttpConstants.PROXY_AUTHORIZATION,authentication);
  2353.                 }
  2354.             }
  2355.             HttpURLConnection httpConn = (HttpURLConnection) connection;
  2356.             if(sslContext!=null) {
  2357.                 
  2358.                 HttpsURLConnection httpsConn = (HttpsURLConnection) httpConn;
  2359.                 httpsConn.setSSLSocketFactory(sslContext.getSocketFactory());
  2360.                 if(!request.isHostnameVerifier()) {
  2361.                     SSLHostNameVerifierDisabled disabilitato = new SSLHostNameVerifierDisabled(LoggerWrapperFactory.getLogger(HttpUtilities.class));
  2362.                     httpsConn.setHostnameVerifier(disabilitato);
  2363.                 }
  2364.             }

  2366.             String contentType = request.getContentType();
  2367.             if(contentType!=null){
  2368.                 httpConn.setRequestProperty(HttpConstants.CONTENT_TYPE,contentType);
  2369.             }
  2370.             else if(request.getContent()!=null){
  2371.                 String ct = request.getHeaderFirstValue(HttpConstants.CONTENT_TYPE);
  2372.                 if(ct==null || StringUtils.isEmpty(ct)) {
  2373.                     throw new UtilsException("Content require a Content Type");
  2374.                 }
  2375.                 else {
  2376.                     contentType = ct; // negli header verra impostato sotto
  2377.                 }
  2378.             }
  2379.             
  2380.             httpConn.setConnectTimeout(request.getConnectTimeout());
  2381.             httpConn.setReadTimeout(request.getReadTimeout());
  2382.             
  2383.             if(request.getFollowRedirects()!=null) {
  2384.                 httpConn.setInstanceFollowRedirects(request.getFollowRedirects());
  2385.             }
  2386.             else {
  2387.                 httpConn.setInstanceFollowRedirects(false);
  2388.             }
  2389.             
  2390.             if(request.getUsername()!=null && request.getPassword()!=null){
  2391.                 String authentication = request.getUsername() + ":" + request.getPassword();
  2392.                 authentication = HttpConstants.AUTHORIZATION_PREFIX_BASIC + Base64Utilities.encodeAsString(authentication.getBytes());
  2393.                 httpConn.setRequestProperty(HttpConstants.AUTHORIZATION,authentication);
  2394.             }
  2395.             
  2396.             Map<String, List<String>> requestHeaders = request.getHeadersValues();
  2397.             if(requestHeaders!=null && requestHeaders.size()>0){
  2398.                 Iterator<String> itReq = requestHeaders.keySet().iterator();
  2399.                 while (itReq.hasNext()) {
  2400.                     String key = itReq.next();
  2401.                     List<String> values = requestHeaders.get(key);
  2402.                     if(values!=null && !values.isEmpty()) {
  2403.                         for (String value : values) {
  2404.                             httpConn.addRequestProperty(key, value);        
  2405.                         }
  2406.                     }
  2407.                 }
  2408.             }
  2409.             
  2410.             boolean sendThrottling = false;
  2411.             if(request.getThrottlingSendByte()!=null && request.getThrottlingSendByte()>0 && 
  2412.                     request.getThrottlingSendMs()!=null && request.getThrottlingSendMs()>0) {
  2413.                 sendThrottling = true;
  2414.             }
  2415.             
  2416.             if(request.getMethod()==null){
  2417.                 throw new UtilsException("HttpMethod required");
  2418.             }
  2419.             if(sendThrottling || request.isForceTransferEncodingChunked()) {
  2420.                 httpConn.setChunkedStreamingMode(0);
  2421.             }
  2422.             setStream(httpConn, request.getMethod(), contentType);

  2424.             HttpBodyParameters httpContent = new  HttpBodyParameters(request.getMethod(), contentType);
  2425.             // Spedizione byte
  2426.             if(httpContent.isDoOutput() && request.getContent() != null){
  2427.                 OutputStream out = httpConn.getOutputStream();
  2428.                 /**System.out.println("Classe '"+out.getClass().getName()+"'");*/
  2429.                 if(sendThrottling) {
  2430.                     int lengthSendContent = request.getContent().length;
  2431.                     for (int i = 0; i < lengthSendContent; ) {
  2432.                         int length = request.getThrottlingSendByte();
  2433.                         int remaining = lengthSendContent-i;
  2434.                         if(remaining<length) {
  2435.                             length = remaining;
  2436.                         }
  2437.                         out.write(request.getContent(),i,length);
  2438.                         i = i+length;
  2439.                         out.flush();
  2440.                         /**System.out.println("Spediti "+length+" bytes");*/
  2441.                         Utilities.sleep(request.getThrottlingSendMs());
  2442.                     }
  2443.                 }
  2444.                 else {
  2445.                     out.write(request.getContent());
  2446.                 }
  2447.                 out.flush();
  2448.                 out.close();
  2449.             }
  2450.             else if(httpContent.isDoOutput() && request.getContentStream() != null){
  2451.                 OutputStream out = httpConn.getOutputStream();
  2452.                 CopyStream.copy(request.getContentStream(), out);
  2453.             }
  2454.             
  2455.             HttpResponse response = new HttpResponse();
  2456.             
  2457.             // Ricezione header
  2458.             Map<String, List<String>> mapHeaderHttpResponse = httpConn.getHeaderFields();
  2459.             if(mapHeaderHttpResponse!=null && mapHeaderHttpResponse.size()>0){
  2460.                 Iterator<String> itHttpResponse = mapHeaderHttpResponse.keySet().iterator();
  2461.                 while(itHttpResponse.hasNext()){
  2462.                     String keyHttpResponse = itHttpResponse.next();
  2463.                     List<String> valueHttpResponse = mapHeaderHttpResponse.get(keyHttpResponse);
  2464.                     if(keyHttpResponse==null){ // Check per evitare la coppia che ha come chiave null e come valore HTTP OK 200
  2465.                         keyHttpResponse=HttpConstants.RETURN_CODE;
  2466.                     }
  2467.                     response.addHeader(keyHttpResponse, valueHttpResponse);
  2468.                 }
  2469.             }
  2470.             
  2471.             // ContentType Risposta
  2472.             if(response.getHeadersValues()!=null && !response.getHeadersValues().isEmpty()){
  2473.                 response.setContentType(response.getHeaderFirstValue(HttpConstants.CONTENT_TYPE));
  2474.             }

  2476.             // Ricezione Result HTTP Code
  2477.             int resultHTTPOperation = httpConn.getResponseCode();

  2479.             response.setResultHTTPOperation(resultHTTPOperation);
  2480.             
  2481.             // Ricezione Risposta
  2482.             if(httpContent.isDoInput()){
  2483.                 outResponse = new ByteArrayOutputStream();
  2484.                 if(resultHTTPOperation>399){
  2485.                     is = httpConn.getErrorStream();
  2486.                     if(is==null){
  2487.                         is = httpConn.getInputStream();
  2488.                     }
  2489.                 }else{
  2490.                     is = httpConn.getInputStream();
  2491.                     if(is==null){
  2492.                         is = httpConn.getErrorStream();
  2493.                     }
  2494.                 }
  2495.                 CopyStream.copy(is, outResponse);
  2496.                 is.close();
  2497.                 outResponse.flush();
  2498.                 outResponse.close();
  2499.                 response.setContent(outResponse.toByteArray());
  2500.             }
  2501.                 
  2502.             // fine HTTP.
  2503.             httpConn.disconnect();
  2504.     
  2505.             // certificati server
  2506.             if(ocspTrustManager!=null) {
  2507.                 response.setServerCertificate(ocspTrustManager.getPeerCertificates());
  2508.             }
  2509.             
  2510.             return response;
  2511.         }catch(Exception e){
  2512.             try{
  2513.                 if(is!=null)
  2514.                     is.close();
  2515.             }catch(Exception eis){
  2516.                 // ignore
  2517.             }
  2518.             try{
  2519.                 if(outResponse!=null)
  2520.                     outResponse.close();
  2521.             }catch(Exception eis){
  2522.                 // ignore
  2523.             }
  2524.             throw new UtilsException(e.getMessage(),e);
  2525.         }
  2526.         finally{
  2527.             try{
  2528.                 if(finKeyStore!=null){
  2529.                     finKeyStore.close();
  2530.                 }
  2531.             }catch(Exception e){
  2532.                 // ignore
  2533.             }
  2534.             try{
  2535.                 if(finTrustStore!=null){
  2536.                     finTrustStore.close();
  2537.                 }
  2538.             }catch(Exception e){
  2539.                 // close
  2540.             }
  2541.         }
  2542.     }




  2547.     
  2548.     
  2549.     /* ********* CHECK ************ */
  2550.     
  2551.     // check (no options)
  2552.     
  2553.     public static void check(String path) throws UtilsException,HttpUtilsException{
  2554.         check(path, HTTP_READ_CONNECTION_TIMEOUT, HTTP_CONNECTION_TIMEOUT, null, null, 
  2555.                 (HttpOptions[]) null);
  2556.     }
  2557.     public static void check(String path,int readTimeout,int connectTimeout) throws UtilsException,HttpUtilsException{
  2558.         check(path, readTimeout, connectTimeout, null, null, 
  2559.                 (HttpOptions[]) null);
  2560.     }
  2561.     public static void check(String path,String username,String password) throws UtilsException,HttpUtilsException{
  2562.         check(path, HTTP_READ_CONNECTION_TIMEOUT, HTTP_CONNECTION_TIMEOUT, username, password, 
  2563.                 (HttpOptions[]) null);
  2564.     }
  2565.     public static void check(String path,int readTimeout,int connectTimeout,String username,String password) throws UtilsException,HttpUtilsException{
  2566.         check(path, readTimeout, connectTimeout, username, password, 
  2567.                 (HttpOptions[]) null);
  2568.     }
  2569.     
  2570.     // check (options)
  2571.     
  2572.     public static void check(String path,
  2573.             HttpOptions ... options) throws UtilsException,HttpUtilsException{
  2574.         check(path, HTTP_READ_CONNECTION_TIMEOUT, HTTP_CONNECTION_TIMEOUT, null, null,
  2575.                 options);
  2576.     }
  2577.     public static void check(String path,int readTimeout,int connectTimeout,
  2578.             HttpOptions ... options) throws UtilsException,HttpUtilsException{
  2579.         check(path, readTimeout, connectTimeout, null, null,
  2580.                 options);
  2581.     }
  2582.     public static void check(String path,String username,String password,
  2583.             HttpOptions ... options) throws UtilsException,HttpUtilsException{
  2584.         check(path, HTTP_READ_CONNECTION_TIMEOUT, HTTP_CONNECTION_TIMEOUT, username, password,
  2585.                 options);
  2586.     }   
  2587.     public static void check(String path,int readTimeout,int connectTimeout,String username,String password,
  2588.             HttpOptions ... options) throws UtilsException,HttpUtilsException{
  2589.         
  2590.         HttpRequest httpRequest = new HttpRequest();
  2591.         httpRequest.setUrl(path);
  2592.         httpRequest.setReadTimeout(readTimeout);
  2593.         httpRequest.setConnectTimeout(connectTimeout);
  2594.         httpRequest.setUsername(username);
  2595.         httpRequest.setPassword(password);
  2596.         httpRequest.setMethod(HttpRequestMethod.GET);
  2597.         
  2598.         if(options!=null && options.length>0) {
  2599.             for (HttpOptions httpOptions : options) {
  2600.                 httpOptions.fill(httpRequest);
  2601.             }
  2602.         }
  2603.         
  2604.         check(httpRequest);
  2605.         
  2606.     }
  2607.     
  2608.     
  2609.     
  2610.     
  2611.     // checkHTTPS (no options)
  2612.     
  2613.     public static void checkHTTPS(String path,
  2614.             String trustStore, String trustStorePassword, String trustStoreType) throws UtilsException,HttpUtilsException{
  2615.         checkHTTPS(path, HTTP_READ_CONNECTION_TIMEOUT, HTTP_CONNECTION_TIMEOUT, null, null,
  2616.                 trustStore, trustStorePassword, trustStoreType,
  2617.                 null, 
  2618.                 (HttpOptions[]) null);
  2619.     }
  2620.     public static void checkHTTPS(String path,
  2621.             String trustStore, String trustStorePassword, String trustStoreType,
  2622.             String crlPath) throws UtilsException,HttpUtilsException{
  2623.         checkHTTPS(path, HTTP_READ_CONNECTION_TIMEOUT, HTTP_CONNECTION_TIMEOUT, null, null,
  2624.                 trustStore, trustStorePassword, trustStoreType,
  2625.                 crlPath, 
  2626.                 (HttpOptions[]) null);
  2627.     }
  2628.     
  2629.     public static void checkHTTPS(String path,int readTimeout,int connectTimeout,
  2630.             String trustStore, String trustStorePassword, String trustStoreType) throws UtilsException,HttpUtilsException{
  2631.         checkHTTPS(path, readTimeout, connectTimeout, null, null,
  2632.                 trustStore, trustStorePassword, trustStoreType,
  2633.                 null, 
  2634.                 (HttpOptions[]) null);
  2635.     }
  2636.     public static void checkHTTPS(String path,int readTimeout,int connectTimeout,
  2637.             String trustStore, String trustStorePassword, String trustStoreType,
  2638.             String crlPath) throws UtilsException,HttpUtilsException{
  2639.         checkHTTPS(path, readTimeout, connectTimeout, null, null,
  2640.                 trustStore, trustStorePassword, trustStoreType,
  2641.                 crlPath, 
  2642.                 (HttpOptions[]) null);
  2643.     }
  2644.     
  2645.     public static void checkHTTPS(String path,String username,String password,
  2646.             String trustStore, String trustStorePassword, String trustStoreType) throws UtilsException,HttpUtilsException{
  2647.         checkHTTPS(path, HTTP_READ_CONNECTION_TIMEOUT, HTTP_CONNECTION_TIMEOUT, username, password,
  2648.                 trustStore, trustStorePassword, trustStoreType,
  2649.                 null, 
  2650.                 (HttpOptions[]) null);
  2651.     }
  2652.     public static void checkHTTPS(String path,String username,String password,
  2653.             String trustStore, String trustStorePassword, String trustStoreType,
  2654.             String crlPath) throws UtilsException,HttpUtilsException{
  2655.         checkHTTPS(path, HTTP_READ_CONNECTION_TIMEOUT, HTTP_CONNECTION_TIMEOUT, username, password,
  2656.                 trustStore, trustStorePassword, trustStoreType,
  2657.                 crlPath, 
  2658.                 (HttpOptions[]) null);
  2659.     }
  2660.     
  2661.     public static void checkHTTPS(String path,int readTimeout,int connectTimeout,String username,String password,
  2662.             String trustStore, String trustStorePassword, String trustStoreType) throws UtilsException,HttpUtilsException{
  2663.         checkHTTPS(path,readTimeout,connectTimeout,username,password,
  2664.                 trustStore, trustStorePassword, trustStoreType,
  2665.                 null, 
  2666.                 (HttpOptions[]) null);
  2667.     }
  2668.     
  2669.     public static void checkHTTPS(String path,int readTimeout,int connectTimeout,String username,String password,
  2670.             String trustStore, String trustStorePassword, String trustStoreType,
  2671.             String crlPath) throws UtilsException,HttpUtilsException{
  2672.         checkHTTPS(path,readTimeout,connectTimeout,username,password,
  2673.                 trustStore, trustStorePassword, trustStoreType,
  2674.                 crlPath, 
  2675.                 (HttpOptions[]) null);
  2676.     }
  2677.     
  2678.     
  2679.     // checkHTTPS (options)
  2680.     
  2681.     public static void checkHTTPS(String path,
  2682.             String trustStore, String trustStorePassword, String trustStoreType,
  2683.             HttpOptions ... options) throws UtilsException,HttpUtilsException{
  2684.         checkHTTPS(path, HTTP_READ_CONNECTION_TIMEOUT, HTTP_CONNECTION_TIMEOUT, null, null,
  2685.                 trustStore, trustStorePassword, trustStoreType,
  2686.                 null,
  2687.                 options);
  2688.     }
  2689.     public static void checkHTTPS(String path,
  2690.             String trustStore, String trustStorePassword, String trustStoreType,
  2691.             String crlPath,
  2692.             HttpOptions ... options) throws UtilsException,HttpUtilsException{
  2693.         checkHTTPS(path, HTTP_READ_CONNECTION_TIMEOUT, HTTP_CONNECTION_TIMEOUT, null, null,
  2694.                 trustStore, trustStorePassword, trustStoreType,
  2695.                 crlPath,
  2696.                 options);
  2697.     }
  2698.     
  2699.     public static void checkHTTPS(String path,int readTimeout,int connectTimeout,
  2700.             String trustStore, String trustStorePassword, String trustStoreType,
  2701.             HttpOptions ... options) throws UtilsException,HttpUtilsException{
  2702.         checkHTTPS(path, readTimeout, connectTimeout, null, null,
  2703.                 trustStore, trustStorePassword, trustStoreType,
  2704.                 null,
  2705.                 options);
  2706.     }
  2707.     public static void checkHTTPS(String path,int readTimeout,int connectTimeout,
  2708.             String trustStore, String trustStorePassword, String trustStoreType,
  2709.             String crlPath,
  2710.             HttpOptions ... options) throws UtilsException,HttpUtilsException{
  2711.         checkHTTPS(path, readTimeout, connectTimeout, null, null,
  2712.                 trustStore, trustStorePassword, trustStoreType,
  2713.                 crlPath,
  2714.                 options);
  2715.     }
  2716.     
  2717.     public static void checkHTTPS(String path,String username,String password,
  2718.             String trustStore, String trustStorePassword, String trustStoreType,
  2719.             HttpOptions ... options) throws UtilsException,HttpUtilsException{
  2720.         checkHTTPS(path, HTTP_READ_CONNECTION_TIMEOUT, HTTP_CONNECTION_TIMEOUT, username, password,
  2721.                 trustStore, trustStorePassword, trustStoreType,
  2722.                 null,
  2723.                 options);
  2724.     }
  2725.     public static void checkHTTPS(String path,String username,String password,
  2726.             String trustStore, String trustStorePassword, String trustStoreType,
  2727.             String crlPath,
  2728.             HttpOptions ... options) throws UtilsException,HttpUtilsException{
  2729.         checkHTTPS(path, HTTP_READ_CONNECTION_TIMEOUT, HTTP_CONNECTION_TIMEOUT, username, password,
  2730.                 trustStore, trustStorePassword, trustStoreType,
  2731.                 crlPath,
  2732.                 options);
  2733.     }
  2734.     
  2735.     public static void checkHTTPS(String path,int readTimeout,int connectTimeout,String username,String password,
  2736.             String trustStore, String trustStorePassword, String trustStoreType,
  2737.             HttpOptions ... options) throws UtilsException,HttpUtilsException{
  2738.         checkHTTPS(path,readTimeout,connectTimeout,username,password,
  2739.                 trustStore, trustStorePassword, trustStoreType,
  2740.                 null,
  2741.                 options);
  2742.     }
  2743.     public static void checkHTTPS(String path,int readTimeout,int connectTimeout,String username,String password,
  2744.             String trustStore, String trustStorePassword, String trustStoreType,
  2745.             String crlPath,
  2746.             HttpOptions ... options) throws UtilsException,HttpUtilsException{
  2747.         
  2748.         HttpRequest httpRequest = new HttpRequest();
  2749.         httpRequest.setUrl(path);
  2750.         httpRequest.setReadTimeout(readTimeout);
  2751.         httpRequest.setConnectTimeout(connectTimeout);
  2752.         httpRequest.setUsername(username);
  2753.         httpRequest.setPassword(password);
  2754.         httpRequest.setMethod(HttpRequestMethod.GET);
  2755.         
  2756.         httpRequest.setTrustStorePath(trustStore);
  2757.         httpRequest.setTrustStorePassword(trustStorePassword);
  2758.         httpRequest.setTrustStoreType(trustStoreType);
  2759.         httpRequest.setCrlPath(crlPath);
  2760.         
  2761.         if(options!=null && options.length>0) {
  2762.             for (HttpOptions httpOptions : options) {
  2763.                 httpOptions.fill(httpRequest);
  2764.             }
  2765.         }
  2766.         
  2767.         check(httpRequest);
  2768.         
  2769.     }
  2770.     
  2771.     
  2772.     
  2773.     
  2774.     
  2775.     // checkHTTPS (no options)
  2776.     
  2777.     public static void checkHTTPS(String path,
  2778.             KeyStore trustStore) throws UtilsException,HttpUtilsException{
  2779.         checkHTTPS(path, HTTP_READ_CONNECTION_TIMEOUT, HTTP_CONNECTION_TIMEOUT, null, null,
  2780.                 trustStore, null, 
  2781.                 (HttpOptions[]) null);
  2782.     }
  2783.     public static void checkHTTPS(String path,
  2784.             KeyStore trustStore, CertStore crlStore) throws UtilsException,HttpUtilsException{
  2785.         checkHTTPS(path, HTTP_READ_CONNECTION_TIMEOUT, HTTP_CONNECTION_TIMEOUT, null, null,
  2786.                 trustStore, crlStore, 
  2787.                 (HttpOptions[]) null);
  2788.     }
  2789.     
  2790.     public static void checkHTTPS(String path,int readTimeout,int connectTimeout,
  2791.             KeyStore trustStore) throws UtilsException,HttpUtilsException{
  2792.         checkHTTPS(path, readTimeout, connectTimeout, null, null,
  2793.                 trustStore, null, 
  2794.                 (HttpOptions[]) null);
  2795.     }
  2796.     public static void checkHTTPS(String path,int readTimeout,int connectTimeout,
  2797.             KeyStore trustStore, CertStore crlStore) throws UtilsException,HttpUtilsException{
  2798.         checkHTTPS(path, readTimeout, connectTimeout, null, null,
  2799.                 trustStore, crlStore, 
  2800.                 (HttpOptions[]) null);
  2801.     }
  2802.     
  2803.     public static void checkHTTPS(String path,String username,String password,
  2804.             KeyStore trustStore) throws UtilsException,HttpUtilsException{
  2805.         checkHTTPS(path, HTTP_READ_CONNECTION_TIMEOUT, HTTP_CONNECTION_TIMEOUT, username, password,
  2806.                 trustStore, null, 
  2807.                 (HttpOptions[]) null);
  2808.     }
  2809.     public static void checkHTTPS(String path,String username,String password,
  2810.             KeyStore trustStore, CertStore crlStore) throws UtilsException,HttpUtilsException{
  2811.         checkHTTPS(path, HTTP_READ_CONNECTION_TIMEOUT, HTTP_CONNECTION_TIMEOUT, username, password,
  2812.                 trustStore, crlStore, 
  2813.                 (HttpOptions[]) null);
  2814.     }   
  2815.     
  2816.     public static void checkHTTPS(String path,int readTimeout,int connectTimeout,String username,String password,
  2817.             KeyStore trustStore) throws UtilsException,HttpUtilsException{
  2818.         checkHTTPS(path,readTimeout,connectTimeout,username,password,
  2819.                 trustStore, null, 
  2820.                 (HttpOptions[]) null);
  2821.     }
  2822.     
  2823.     public static void checkHTTPS(String path,int readTimeout,int connectTimeout,String username,String password,
  2824.             KeyStore trustStore, CertStore crlStore) throws UtilsException,HttpUtilsException{
  2825.         checkHTTPS(path,readTimeout,connectTimeout,username,password,
  2826.                 trustStore, crlStore, 
  2827.                 (HttpOptions[]) null);
  2828.     }
  2829.     
  2830.     
  2831.     
  2832.     // checkHTTPS (options)
  2833.     
  2834.     public static void checkHTTPS(String path,
  2835.             KeyStore trustStore,
  2836.             HttpOptions ... options) throws UtilsException,HttpUtilsException{
  2837.         checkHTTPS(path, HTTP_READ_CONNECTION_TIMEOUT, HTTP_CONNECTION_TIMEOUT, null, null,
  2838.                 trustStore, null,
  2839.                 options);
  2840.     }
  2841.     public static void checkHTTPS(String path,
  2842.             KeyStore trustStore, CertStore crlStore,
  2843.             HttpOptions ... options) throws UtilsException,HttpUtilsException{
  2844.         checkHTTPS(path, HTTP_READ_CONNECTION_TIMEOUT, HTTP_CONNECTION_TIMEOUT, null, null,
  2845.                 trustStore, crlStore,
  2846.                 options);
  2847.     }
  2848.     
  2849.     public static void checkHTTPS(String path,int readTimeout,int connectTimeout,
  2850.             KeyStore trustStore,
  2851.             HttpOptions ... options) throws UtilsException,HttpUtilsException{
  2852.         checkHTTPS(path, readTimeout, connectTimeout, null, null,
  2853.                 trustStore, null,
  2854.                 options);
  2855.     }
  2856.     public static void checkHTTPS(String path,int readTimeout,int connectTimeout,
  2857.             KeyStore trustStore, CertStore crlStore,
  2858.             HttpOptions ... options) throws UtilsException,HttpUtilsException{
  2859.         checkHTTPS(path, readTimeout, connectTimeout, null, null,
  2860.                 trustStore, crlStore,
  2861.                 options);
  2862.     }
  2863.     
  2864.     public static void checkHTTPS(String path,String username,String password,
  2865.             KeyStore trustStore,
  2866.             HttpOptions ... options) throws UtilsException,HttpUtilsException{
  2867.         checkHTTPS(path, HTTP_READ_CONNECTION_TIMEOUT, HTTP_CONNECTION_TIMEOUT, username, password,
  2868.                 trustStore, null,
  2869.                 options);
  2870.     }
  2871.     public static void checkHTTPS(String path,String username,String password,
  2872.             KeyStore trustStore, CertStore crlStore,
  2873.             HttpOptions ... options) throws UtilsException,HttpUtilsException{
  2874.         checkHTTPS(path, HTTP_READ_CONNECTION_TIMEOUT, HTTP_CONNECTION_TIMEOUT, username, password,
  2875.                 trustStore, crlStore,
  2876.                 options);
  2877.     }   
  2878.     
  2879.     public static void checkHTTPS(String path,int readTimeout,int connectTimeout,String username,String password,
  2880.             KeyStore trustStore,
  2881.             HttpOptions ... options) throws UtilsException,HttpUtilsException{
  2882.         checkHTTPS(path,readTimeout,connectTimeout,username,password,
  2883.                 trustStore, null,
  2884.                 options);
  2885.     }
  2886.     
  2887.     public static void checkHTTPS(String path,int readTimeout,int connectTimeout,String username,String password,
  2888.             KeyStore trustStore, CertStore crlStore,
  2889.             HttpOptions ... options) throws UtilsException,HttpUtilsException{
  2890.         
  2891.         HttpRequest httpRequest = new HttpRequest();
  2892.         httpRequest.setUrl(path);
  2893.         httpRequest.setReadTimeout(readTimeout);
  2894.         httpRequest.setConnectTimeout(connectTimeout);
  2895.         httpRequest.setUsername(username);
  2896.         httpRequest.setPassword(password);
  2897.         httpRequest.setMethod(HttpRequestMethod.GET);
  2898.         
  2899.         httpRequest.setTrustStore(trustStore);
  2900.         httpRequest.setCrlStore(crlStore);
  2901.         
  2902.         if(options!=null && options.length>0) {
  2903.             for (HttpOptions httpOptions : options) {
  2904.                 httpOptions.fill(httpRequest);
  2905.             }
  2906.         }
  2907.         
  2908.         check(httpRequest);
  2909.         
  2910.     }
  2911.     
  2912.     
  2913.     
  2914.     // checkHTTPS_trustAllCerts (no options)
  2915.     
  2916.     public static void checkHTTPS_trustAllCerts(String path) throws UtilsException, HttpUtilsException{
  2917.         checkHTTPS_trustAllCerts(path, HTTP_READ_CONNECTION_TIMEOUT, HTTP_CONNECTION_TIMEOUT, null, null, 
  2918.                 (HttpOptions[]) null);
  2919.     }
  2920.     public static void checkHTTPS_trustAllCerts(String path,int readTimeout,int connectTimeout) throws UtilsException, HttpUtilsException{
  2921.         checkHTTPS_trustAllCerts(path, readTimeout, connectTimeout, null, null, 
  2922.                 (HttpOptions[]) null);
  2923.     }
  2924.     public static void checkHTTPS_trustAllCerts(String path,String username,String password) throws UtilsException, HttpUtilsException{
  2925.         checkHTTPS_trustAllCerts(path, HTTP_READ_CONNECTION_TIMEOUT, HTTP_CONNECTION_TIMEOUT, username, password, 
  2926.                 (HttpOptions[]) null);
  2927.     }   
  2928.     public static void checkHTTPS_trustAllCerts(String path,int readTimeout,int connectTimeout,String username,String password) throws UtilsException,HttpUtilsException{
  2929.         checkHTTPS_trustAllCerts(path, readTimeout, connectTimeout, username, password, 
  2930.                 (HttpOptions[]) null);
  2931.     }
  2932.     
  2933.     // checkHTTPS_trustAllCerts (options)
  2934.     
  2935.     public static void checkHTTPS_trustAllCerts(String path,
  2936.             HttpOptions ... options) throws UtilsException, HttpUtilsException{
  2937.         checkHTTPS_trustAllCerts(path, HTTP_READ_CONNECTION_TIMEOUT, HTTP_CONNECTION_TIMEOUT, null, null,
  2938.                 options);
  2939.     }
  2940.     public static void checkHTTPS_trustAllCerts(String path,int readTimeout,int connectTimeout,
  2941.             HttpOptions ... options) throws UtilsException, HttpUtilsException{
  2942.         checkHTTPS_trustAllCerts(path, readTimeout, connectTimeout, null, null,
  2943.                 options);
  2944.     }
  2945.     public static void checkHTTPS_trustAllCerts(String path,String username,String password,
  2946.             HttpOptions ... options) throws UtilsException, HttpUtilsException{
  2947.         checkHTTPS_trustAllCerts(path, HTTP_READ_CONNECTION_TIMEOUT, HTTP_CONNECTION_TIMEOUT, username, password,
  2948.                 options);
  2949.     }   
  2950.     public static void checkHTTPS_trustAllCerts(String path,int readTimeout,int connectTimeout,String username,String password,
  2951.             HttpOptions ... options) throws UtilsException,HttpUtilsException{
  2952.         HttpRequest httpRequest = new HttpRequest();
  2953.         httpRequest.setUrl(path);
  2954.         httpRequest.setReadTimeout(readTimeout);
  2955.         httpRequest.setConnectTimeout(connectTimeout);
  2956.         httpRequest.setUsername(username);
  2957.         httpRequest.setPassword(password);
  2958.         httpRequest.setMethod(HttpRequestMethod.GET);
  2959.         
  2960.         httpRequest.setTrustAllCerts(true);
  2961.         
  2962.         if(options!=null && options.length>0) {
  2963.             for (HttpOptions httpOptions : options) {
  2964.                 httpOptions.fill(httpRequest);
  2965.             }
  2966.         }
  2967.         
  2968.         check(httpRequest);
  2969.         
  2970.     }
  2971.     
  2972.     public static void check(HttpRequest httpRequest) throws UtilsException,HttpUtilsException{
  2973.         
  2974.         HttpResponse response = null;
  2975.         try{
  2976.             response = httpInvoke(httpRequest);
  2977.             
  2978.         }catch(Exception e){
  2979.             throw new UtilsException(e.getMessage(),e);
  2980.         }
  2981.         
  2982.         check(response);
  2983.         
  2984.     }
  2985.     
  2986.     public static void check(HttpResponse response) throws HttpUtilsException{
  2987.         if(response.getResultHTTPOperation()!=200){
  2988.             if(response.getContent()!=null){
  2989.                 throw new HttpUtilsException(response.getResultHTTPOperation(), "Response Code ("+response.getResultHTTPOperation()+"): "+new String(response.getContent()));
  2990.             }
  2991.             else{
  2992.                 throw new HttpUtilsException(response.getResultHTTPOperation(), "Response Code ("+response.getResultHTTPOperation()+")");
  2993.             }
  2994.         }
  2995.     }
  2996.     
  2997.     
  2998.     
  2999.     
  3000.     
  3001.     
  3002.     /* ********* VALIDATE URI ************ */
  3003.     
  3004.     public static void validateUri(String uri,boolean checkEsistenzaFile) throws UtilsException,java.net.MalformedURLException{
  3005.         
  3006.         if (uri.startsWith("http://")
  3007.                 || uri.startsWith(TEST_FILE_ORIGIN)) {

  3009.             if(checkEsistenzaFile)
  3010.                 HttpUtilities.requestHTTPFile(uri);
  3011.             else
  3012.                 RegExpUtilities.validateUrl(uri);

  3014.         } else {
  3015.             File f = new File(uri);
  3016.             if(checkEsistenzaFile){
  3017.                 if(f.exists()==false){
  3018.                     throw new UtilsException("File non esistente");
  3019.                 }
  3020.                 else if(f.isDirectory()){
  3021.                     throw new UtilsException("File e' una directory");
  3022.                 }else if(f.canRead()==false){
  3023.                     throw new UtilsException("File non accessibile");
  3024.                 }
  3025.             }
  3026.         }
  3027.     }
  3028.     
  3029.     
  3030.     /* ********* DIGEST HEADER ************ */
  3031.     
  3032.     @Deprecated
  3033.     public static String getDigestHeaderValueByCommons(byte[] content, String algorithm) throws UtilsException{
  3034.         String digestValue = null;
  3035.         if(algorithm.equals(HttpConstants.DIGEST_ALGO_MD5)) {
  3036.             digestValue = DigestUtils.md5Hex(content);
  3037.         }
  3038.         else if(algorithm.equals(HttpConstants.DIGEST_ALGO_SHA_1) || algorithm.equals(HttpConstants.DIGEST_ALGO_SHA)) {
  3039.             digestValue = DigestUtils.sha1Hex(content);
  3040.         }
  3041.         else if(algorithm.equals(HttpConstants.DIGEST_ALGO_SHA_256)) {
  3042.             digestValue = DigestUtils.sha256Hex(content);
  3043.         }
  3044.         else if(algorithm.equals(HttpConstants.DIGEST_ALGO_SHA_384)) {
  3045.             digestValue = DigestUtils.sha384Hex(content);
  3046.         }
  3047.         else if(algorithm.equals(HttpConstants.DIGEST_ALGO_SHA_512)) {
  3048.             digestValue = DigestUtils.sha512Hex(content);
  3049.         }
  3050.         else {
  3051.             throw new UtilsException("Digest algorithm '"+algorithm+"' unsupported");
  3052.         }
  3053.         return algorithm+"="+digestValue;
  3054.     }
  3055.     
  3056.     public static String getDigestHeaderValue(byte[] content, String algorithm) throws UtilsException{
  3057.         // RFC 5843, il quale estende il precedente RFC 3230, vengono specificati sia gli algoritmi SHA 256 e 512 che la loro codifica, la quale deve essere base64.
  3058.         return getDigestHeaderValue(content, algorithm, DigestEncoding.BASE64);
  3059.     }
  3060.     public static String getDigestHeaderValue(byte[] content, String algorithm, DigestEncoding digestEncoding) throws UtilsException{
  3061.         boolean rfc3230 = true; // aggiunge prefisso algoritmo=
  3062.         return org.openspcoop2.utils.digest.DigestUtils.getDigestValue(content, algorithm, digestEncoding, rfc3230);
  3063.     }
  3064.     public static Map<DigestEncoding, String> getDigestHeaderValues(byte[] content, String algorithm, DigestEncoding ... digestEncoding) throws UtilsException{
  3065.         boolean rfc3230 = true; // aggiunge prefisso algoritmo=
  3066.         return org.openspcoop2.utils.digest.DigestUtils.getDigestValues(content, algorithm, rfc3230, digestEncoding);
  3067.     }
  3068. }
Created with JaCoCo 0.8.8.202204050719