ContentTypeUtilities.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.  */
  20. package org.openspcoop2.utils.transport.http;

  22. import java.util.ArrayList;
  23. import java.util.Iterator;
  24. import java.util.List;
  25. import java.util.Map;

  27. import javax.xml.soap.SOAPException;

  29. import org.openspcoop2.utils.Utilities;
  30. import org.openspcoop2.utils.UtilsException;
  31. import org.openspcoop2.utils.mime.MultipartUtils;
  32. import org.openspcoop2.utils.regexp.RegExpNotFoundException;
  33. import org.openspcoop2.utils.regexp.RegularExpressionEngine;
  34. import org.slf4j.Logger;

  36. //import javax.mail.internet.ContentType;
  37. //import javax.mail.internet.ParameterList;
  38. import com.sun.xml.messaging.saaj.packaging.mime.internet.ContentType;
  39. import com.sun.xml.messaging.saaj.packaging.mime.internet.ParameterList;



  43. /**
  44.  * ContentTypeUtilities
  45.  *
  46.  * @author Andrea Poli (apoli@link.it)
  47.  * @author $Author$
  48.  * @version $Rev$, $Date$
  49.  */
  50. public class ContentTypeUtilities {
  51.     
  52.     
  53.     
  54.     // Utilities generiche
  55.     
  56.     public static void validateContentType(String ct) throws UtilsException{
  57.         try {
  58.             if(ct!=null && !"".equals(ct)) {
  59.                 
  60.                 (new javax.mail.internet.ContentType(ct)).getBaseType(); // uso javax.mail per validare, restituisce un errore migliore
  61.                 
  62.                 if(ContentTypeUtilities.isMultipart(ct)){
  63.                     String internal = ContentTypeUtilities.getInternalMultipartContentType(ct);
  64.                     if(internal!=null){
  65.                         ContentTypeUtilities.isMtom(internal);
  66.                     }
  67.                 }
  68.             }
  69.         }catch(Throwable e) {
  70.             String msgError = e.getMessage();
  71.             if(msgError==null || "".equals(msgError) || "null".equals(msgError)) {
  72.                 msgError = Utilities.getInnerNotEmptyMessageException(e).getMessage();
  73.             }
  74.             if(msgError==null || "".equals(msgError) || "null".equals(msgError)) {
  75.                 msgError = "Parsing failed";
  76.             }
  77.             throw new UtilsException(msgError,e);
  78.         }
  79.     }
  80.     
  81.     public static String buildContentType(String baseType,Map<String, String> parameters) throws UtilsException{
  82.         try{
  83.             ContentType cType = new ContentType(baseType);
  84.             if(parameters!=null && parameters.size()>0){
  85.                 Iterator<String> itP = parameters.keySet().iterator();
  86.                 while (itP.hasNext()) {
  87.                     String parameterName = (String) itP.next();
  88.                     String parameterValue = parameters.get(parameterName);
  89.                     if(cType.getParameterList()==null){
  90.                         cType.setParameterList(new ParameterList());
  91.                     }
  92.                     cType.getParameterList().remove(parameterName);
  93.                     cType.getParameterList().set(parameterName, parameterValue);
  94.                 }
  95.                 
  96.             }
  97.             
  98.             /*
  99.              * //import javax.mail.internet.ContentType;
  100.                 //import javax.mail.internet.ParameterList;

  102.                 import com.sun.xml.messaging.saaj.packaging.mime.internet.ContentType;
  103.                 import com.sun.xml.messaging.saaj.packaging.mime.internet.ParameterList;
  104.                 
  105.                 Utilizzo la versione saaj poiche il toString di javax.mail.internet.ContentType in presenza di un valore con ':' non funziona correttamente e genera valori action*0 e action*1
  106.              * 
  107.              * */
  108.             
  109.             String ct = cType.toString(); // il toString in presenza di action con valore http://... non funziona correttamente e genera valori action*0 e action*1
  110.             
  111.             // Reimplementare il toString non basta poiche' i ':' fanno schiantare un successivo parser del javax.mail.internet.ContentType
  112. //          StringBuilder ctBufferParam = new StringBuilder();
  113. //          ParameterList pList = cType.getParameterList();
  114. //          if(pList!=null && pList.size()>0) {
  115. //              java.util.Enumeration<String> en = pList.getNames();
  116. //              while (en.hasMoreElements()) {
  117. //                  String name = (String) en.nextElement();
  118. //                  ctBufferParam.append("; ");
  119. //                  ctBufferParam.append(name).append("=").append(pList.get(name));
  120. //              }
  121. //          }
  122. //          String ct = cType.getBaseType();
  123. //          if(ctBufferParam.length()>0) {
  124. //              ct = ct + ctBufferParam.toString();
  125. //          }
  126.             ct = normalizeToRfc7230(ct);            
  127.             ct = ct.trim();
  128.             return ct;
  129.         }catch(Exception e){
  130.             throw new RuntimeException("Error during buildContentType: "+e.getMessage(), e);
  131.         }
  132.     }
  133.     
  134.     public static String normalizeToRfc7230(String ct) {
  135.         // Line folding of headers has been deprecated in the latest HTTP RFC:
  136.         // http://tools.ietf.org/html/rfc7230#section-3.2.4
  137.         while (ct.contains("\r\n")) {
  138.             ct = ct.replace("\r\n", " ");
  139.         }
  140.         while (ct.contains("\r")) {
  141.             ct = ct.replace("\r", " ");
  142.         }
  143.         while (ct.contains("\n")) {
  144.             ct = ct.replace("\n", " ");
  145.         }
  146.         while (ct.contains("\t")) {
  147.             ct = ct.replace("\t", " ");
  148.         }
  149.         return ct.trim();
  150.     }
  151.     
  152.     public static String readBaseTypeFromContentType(String cType) throws UtilsException {
  153.         try{
  154.             ContentType contentType = new ContentType(cType);
  155.             return contentType.getBaseType();
  156.         } catch (Exception e) {
  157.             throw new UtilsException(e.getMessage(),e);
  158.         }
  159.     }
  160.     public static String readPrimaryTypeFromContentType(String cType) throws UtilsException {
  161.         try{
  162.             ContentType contentType = new ContentType(cType);
  163.             return contentType.getPrimaryType();
  164.         } catch (Exception e) {
  165.             throw new UtilsException(e.getMessage(),e);
  166.         }
  167.     }
  168.     public static String readSubTypeFromContentType(String cType) throws UtilsException {
  169.         try{
  170.             ContentType contentType = new ContentType(cType);
  171.             return contentType.getSubType();
  172.         } catch (Exception e) {
  173.             throw new UtilsException(e.getMessage(),e);
  174.         }
  175.     }
  176.     
  177.     public static String readCharsetFromContentType(String cType) throws UtilsException {
  178.         try{
  179.             ContentType contentType = new ContentType(cType);
  180.             String charsetParam = contentType.getParameter(HttpConstants.CONTENT_TYPE_PARAMETER_CHARSET); 
  181.             if (charsetParam != null) {
  182.                 return charsetParam.trim();
  183.             }
  184.             return null;
  185.         } catch (Exception e) {
  186.             throw new UtilsException(e.getMessage(),e);
  187.         }
  188.     }
  189.     
  190.     
  191.     
  192.     // match
  193.     
  194.     public static boolean isMatch(Logger logNullable, String contentTypeParam, String contentTypeAtteso) throws UtilsException {
  195.         List<String> l = new ArrayList<>();
  196.         l.add(contentTypeAtteso);
  197.         return isMatch(logNullable, contentTypeParam, l);
  198.     }
  199.     public static boolean isMatch(Logger logNullable, String contentTypeParam, List<String> contentTypeAttesi) throws UtilsException {
  200.         
  201.         if(contentTypeAttesi==null || contentTypeAttesi.isEmpty()) {
  202.             return true;
  203.         }
  204.         
  205.         String baseTypeHttp = contentTypeParam!=null ? ContentTypeUtilities.readBaseTypeFromContentType(contentTypeParam) : null;
  206.         
  207.         boolean found = false;
  208.         for (String checkContentType : contentTypeAttesi) {
  209.             if("empty".equals(checkContentType)){
  210.                 if(baseTypeHttp==null || "".equals(baseTypeHttp)) {
  211.                     found = true;
  212.                     break;
  213.                 }
  214.             }
  215.             else {
  216.                 if(baseTypeHttp==null) {
  217.                     continue;
  218.                 }
  219.                 if(checkContentType==null || "".equals(checkContentType) ||
  220.                         !checkContentType.contains("/") ||
  221.                         checkContentType.startsWith("/") ||
  222.                         checkContentType.endsWith("/")) {
  223.                     throw new UtilsException("Configurazione errata, content type indicato ("+checkContentType+") possiede un formato non corretto (atteso: type/subtype)");
  224.                 }
  225.                 String [] ctVerifica = checkContentType.split("/");
  226.                 String contentTypeEscaped = null;
  227.                 if(ctVerifica!=null && ctVerifica.length==2) {
  228.                     StringBuilder bf = new StringBuilder();
  229.                     String part1 = ctVerifica[0].trim();
  230.                     if("*".equals(part1)) {
  231.                         bf.append("(.+)");
  232.                     }
  233.                     else {
  234.                         // escape special char
  235.                         part1 = part1.replace("+", "\\+");
  236.                         bf.append(part1);
  237.                     }
  238.                     bf.append("/");
  239.                     String part2 = ctVerifica[1].trim();
  240.                     if("*".equals(part2)) {
  241.                         bf.append("(.+)");
  242.                     }
  243.                     else if(part2.startsWith("*")) {
  244.                         bf.append("(.+)");
  245.                         String sub = part2.substring(1);
  246.                         // escape special char
  247.                         sub = sub.replace("+", "\\+");
  248.                         bf.append(sub);
  249.                     }
  250.                     else {
  251.                         // escape special char
  252.                         part2 = part2.replace("+", "\\+");
  253.                         bf.append(part2);
  254.                     }
  255.                     contentTypeEscaped = bf.toString();
  256.                 }
  257.                 boolean isMatchEscaped = false; // gestisce le espressioni type/* e */*+xml
  258.                 boolean isMatchRegExp = false; // gestisce le espressioni regexpType/regexpSubType
  259.                 if(contentTypeEscaped!=null) {
  260.                     try {
  261.                         isMatchEscaped = RegularExpressionEngine.isMatch(baseTypeHttp, contentTypeEscaped);
  262.                     }catch(RegExpNotFoundException notFound) {
  263.                         // ignore
  264.                     }catch(Exception e) {
  265.                         throw new UtilsException(e.getMessage(),e);
  266.                     }
  267.                 }
  268.                 if(!isMatchEscaped) {
  269.                     try {
  270.                         isMatchRegExp = RegularExpressionEngine.isMatch(baseTypeHttp, checkContentType);
  271.                     }catch(RegExpNotFoundException notFound) {
  272.                         // ignore
  273.                     }catch(Exception e) {
  274.                         if(contentTypeEscaped==null) {
  275.                             throw new UtilsException(e.getMessage(),e);
  276.                         }
  277.                         else {
  278.                             // ignore
  279.                             // per evitare errori tipo:
  280.                             //org.openspcoop2.utils.UtilsException: Validazione del pattern indicato [*/*son] fallita: Dangling meta character '*' near index 0
  281.                             //                                                                        */*son
  282.                             //                                                                        ^
  283.                             if(logNullable!=null) {
  284.                                 logNullable.debug("isMatch failed: "+e.getMessage(),e);
  285.                             }
  286.                         }
  287.                     }
  288.                 }
  289.                 if(isMatchEscaped || isMatchRegExp) {
  290.                     found = true;
  291.                     break;
  292.                 }
  293.             }
  294.             
  295.         }
  296.         return found;
  297.     }
  298.     
  299.     
  300.     
  301.     
  302.     // Utilities Multipart
  303.     
  304.     public static boolean isMultipartType(String cType) throws UtilsException {
  305.         try{
  306.             ContentType contentType = new ContentType(cType);
  307.             String baseType = contentType.getBaseType();
  308.             if(baseType!=null) {
  309.                 baseType = baseType.toLowerCase();
  310.             }
  311.             if(baseType!=null && baseType.startsWith(HttpConstants.CONTENT_TYPE_MULTIPART_TYPE+"/")){
  312.                 return true;
  313.             }
  314.             return false;
  315.             
  316.         } catch (Exception e) {
  317.             throw new UtilsException(e.getMessage(),e);
  318.         }
  319.     }
  320.     
  321.     @Deprecated
  322.     public static boolean isMultipart(String cType) throws UtilsException {
  323.         return isMultipartRelated(cType);
  324.     }
  325.     public static boolean isMultipartRelated(String cType) throws UtilsException {
  326.         return _isMultipart(cType, HttpConstants.CONTENT_TYPE_MULTIPART_RELATED);
  327.     }
  328.     public static boolean isMultipartMixed(String cType) throws UtilsException {
  329.         return _isMultipart(cType, HttpConstants.CONTENT_TYPE_MULTIPART_MIXED);
  330.     }
  331.     public static boolean isMultipartAlternative(String cType) throws UtilsException {
  332.         return _isMultipart(cType, HttpConstants.CONTENT_TYPE_MULTIPART_ALTERNATIVE);
  333.     }
  334.     public static boolean isMultipartFormData(String cType) throws UtilsException {
  335.         return _isMultipart(cType, HttpConstants.CONTENT_TYPE_MULTIPART_FORM_DATA);
  336.     }
  337.     private static boolean _isMultipart(String cType, String expected) throws UtilsException {
  338.         try{
  339.             ContentType contentType = new ContentType(cType);
  340.             String baseType = contentType.getBaseType();
  341.             if(baseType!=null) {
  342.                 baseType = baseType.toLowerCase();
  343.             }
  344.             if(baseType!=null && baseType.equals(expected)){
  345.                 return true;
  346.             }
  347.             return false;
  348.             
  349.         } catch (Exception e) {
  350.             throw new UtilsException(e.getMessage(),e);
  351.         }
  352.     }
  353.     
  354.     public static boolean isMultipartContentType(String cType) throws UtilsException {
  355.         try{
  356.             ContentType contentType = new ContentType(cType);
  357.             String baseType = contentType.getBaseType();
  358.             if(baseType!=null) {
  359.                 baseType = baseType.toLowerCase();
  360.             }
  361.             if(baseType!=null && baseType.startsWith( (HttpConstants.CONTENT_TYPE_MULTIPART_TYPE+"/")) ){
  362.                 return true;
  363.             }
  364.             return false;
  365.             
  366.         } catch (Exception e) {
  367.             throw new UtilsException(e.getMessage(),e);
  368.         }
  369.     }
  370.     
  371.     public static String getInternalMultipartContentType(String cType) throws UtilsException {
  372.         try{
  373.             ContentType contentType = new ContentType(cType);
  374.             String baseType = contentType.getBaseType();
  375.             if(baseType!=null) {
  376.                 baseType = baseType.toLowerCase();
  377.             }
  378.             String internalContentType = null;
  379.             boolean mtom = false;
  380.             if(baseType == null) {
  381.                 internalContentType = null;
  382.             }
  383.             else if(baseType.equals(HttpConstants.CONTENT_TYPE_MULTIPART_RELATED)){
  384.                 String typeParam = contentType.getParameter(HttpConstants.CONTENT_TYPE_MULTIPART_PARAMETER_TYPE); 
  385.                 if (typeParam != null) {
  386.                     internalContentType = typeParam.toLowerCase();
  387.                     if(HttpConstants.CONTENT_TYPE_APPLICATION_XOP_XML.equals(internalContentType)){
  388.                         mtom = true;
  389.                     }
  390.                 } 
  391.             }
  392.             else {
  393.                 internalContentType = baseType;
  394.             }
  395.             
  396.             if(mtom) {
  397.                 internalContentType = readInternalMultipartMtomContentType(contentType);
  398.             }
  399.             
  400.             return internalContentType;
  401.         } catch (Exception e) {
  402.             throw new UtilsException(e.getMessage(),e);
  403.         }
  404.     }
  405.     
  406.     @Deprecated
  407.     public static String buildMultipartContentType(byte [] message, String type) throws UtilsException{
  408.         return buildMultipartRelatedContentType(message, type);
  409.     }
  410.     public static String buildMultipartRelatedContentType(byte [] message, String type) throws UtilsException{
  411.         return buildMultipartContentType(HttpConstants.CONTENT_TYPE_MULTIPART_RELATED_SUBTYPE, message, type);
  412.     }
  413.     public static String buildMultipartContentType(String subtype, byte [] message, String type) throws UtilsException{
  414.         if(MultipartUtils.messageWithAttachment(message)){
  415.             String IDfirst  = MultipartUtils.firstContentID(message);
  416.             return buildMultipartContentType(subtype, message, type, IDfirst);
  417.         }
  418.         throw new UtilsException("Messaggio non contiene una struttura mime");
  419.     }
  420.     @Deprecated
  421.     public static String buildMultipartContentType(byte [] message, String type, String ID) throws UtilsException{
  422.         return buildMultipartRelatedContentType(message, type, ID);
  423.     }
  424.     public static String buildMultipartRelatedContentType(byte [] message, String type, String ID) throws UtilsException{
  425.         return buildMultipartContentType(HttpConstants.CONTENT_TYPE_MULTIPART_RELATED_SUBTYPE, message, type, ID);
  426.     }
  427.     public static String buildMultipartContentType(String subtype, byte [] message, String type, String ID) throws UtilsException{
  428.         if(MultipartUtils.messageWithAttachment(message)){
  429.                         
  430.             String boundary = MultipartUtils.findBoundary(message);
  431.             if(boundary==null){
  432.                 throw new UtilsException("Errore avvenuto durante la lettura del boundary associato al multipart message.");
  433.             }
  434.             StringBuilder bf = new StringBuilder();
  435.             bf.append(HttpConstants.CONTENT_TYPE_MULTIPART_TYPE+"/"+subtype);
  436.             if(type!=null){
  437.                 bf.append("; ").append(HttpConstants.CONTENT_TYPE_MULTIPART_PARAMETER_TYPE).append("=\"").append(type).append("\"");
  438.             }
  439.             if(ID!=null){
  440.                 bf.append("; ").append(HttpConstants.CONTENT_TYPE_MULTIPART_PARAMETER_START).append("=\"").append(ID).append("\"");
  441.             }
  442.             bf.append("; ").append(HttpConstants.CONTENT_TYPE_MULTIPART_PARAMETER_BOUNDARY).append("=\"").append(boundary.substring(2,boundary.length())).append("\"");
  443.             
  444.             return bf.toString();
  445.         }
  446.         throw new UtilsException("Messaggio non contiene una struttura mime");
  447.     }
  448.     
  449.     
  450.     
  451.     
  452.     // Utilities MTOM
  453.     
  454.     public static boolean isMtom(String cType) throws UtilsException{
  455.         try{
  456.             ContentType contentType = new ContentType(cType);
  457.             String baseType = contentType.getBaseType();
  458.             if(baseType!=null) {
  459.                 baseType = baseType.toLowerCase();
  460.             }
  461.             boolean mtom = false;
  462.             if(baseType!=null && baseType.equals(HttpConstants.CONTENT_TYPE_MULTIPART_RELATED)){
  463.                 String typeParam = contentType.getParameter(HttpConstants.CONTENT_TYPE_MULTIPART_PARAMETER_TYPE); 
  464.                 if (typeParam == null) {
  465.                     throw new SOAPException("Missing '"+HttpConstants.CONTENT_TYPE_MULTIPART_PARAMETER_TYPE+"' parameter in "+HttpConstants.CONTENT_TYPE_MULTIPART_RELATED);
  466.                 } else {
  467.                     String soapContentType = typeParam.toLowerCase();
  468.                     if(HttpConstants.CONTENT_TYPE_APPLICATION_XOP_XML.equals(soapContentType)){
  469.                         mtom = true;
  470.                     }
  471.                 } 
  472.             }
  473.             return mtom;
  474.             
  475.         } catch (Exception e) {
  476.             throw new UtilsException(e.getMessage(),e);
  477.         }
  478.     }
  479.     
  480.     public static String readInternalMultipartMtomContentType(String contentType) throws UtilsException{
  481.         try{
  482.             return readInternalMultipartMtomContentType(new ContentType(contentType));
  483.         }
  484.         catch(UtilsException e){
  485.             throw e;
  486.         }
  487.         catch(Exception e){
  488.             throw new UtilsException(e.getMessage(),e);
  489.         }
  490.     }
  491.     public static String readInternalMultipartMtomContentType(ContentType contentType) throws UtilsException{
  492.         try{
  493.             if(contentType==null){
  494.                 throw new UtilsException("ContentType non fornito");
  495.             }
  496.             
  497.             // baseType
  498.             if(contentType.getBaseType()==null){
  499.                 throw new UtilsException("ContentType.baseType non definito");
  500.             }
  501.             if(HttpConstants.CONTENT_TYPE_MULTIPART_RELATED.equals(contentType.getBaseType().toLowerCase())==false){
  502.                 throw new UtilsException("ContentType.baseType ["+contentType.getBaseType()+
  503.                         "] differente da quello atteso per un messaggio MTOM/XOP ["+HttpConstants.CONTENT_TYPE_MULTIPART_RELATED+"]");
  504.             }
  505.             if(contentType.getParameterList()==null || contentType.getParameterList().size()<=0){
  506.                 throw new UtilsException("ContentType non conforme a quanto definito nella specifica MTOM/XOP (non sono presenti parametri)");
  507.             }
  508.             
  509.             // type
  510.             String type = contentType.getParameter(HttpConstants.CONTENT_TYPE_MULTIPART_PARAMETER_TYPE);
  511.             if(type==null){
  512.                 throw new UtilsException("ContentType non conforme a quanto definito nella specifica MTOM/XOP (Parametro '"+
  513.                         HttpConstants.CONTENT_TYPE_MULTIPART_PARAMETER_TYPE+"' non presente)");
  514.             }
  515.             if(HttpConstants.CONTENT_TYPE_APPLICATION_XOP_XML.equals(type.toLowerCase())==false){
  516.                 throw new UtilsException("ContentType.parameters."+HttpConstants.CONTENT_TYPE_MULTIPART_PARAMETER_TYPE+" ["+type+
  517.                         "] differente da quello atteso per un messaggio MTOM/XOP ["+HttpConstants.CONTENT_TYPE_APPLICATION_XOP_XML+"]");
  518.             }
  519.             
  520.             // startInfo
  521.             String startInfo = contentType.getParameter(HttpConstants.CONTENT_TYPE_MULTIPART_PARAMETER_START_INFO);
  522.             if(startInfo==null){
  523.                 throw new UtilsException("ContentType non conforme a quanto definito nella specifica MTOM/XOP (Parametro '"+
  524.                         HttpConstants.CONTENT_TYPE_MULTIPART_PARAMETER_START_INFO+"' non presente)");
  525.             }
  526.             // startInfo puo' contenere il ';'
  527.             return readBaseTypeFromContentType(startInfo);
  528.             
  529.         }
  530.         catch(UtilsException e){
  531.             throw e;
  532.         }
  533.         catch(Exception e){
  534.             throw new UtilsException(e.getMessage(),e);
  535.         }
  536.     }


  539.     
  540.     public static String readMultipartBoundaryFromContentType(String cType) throws UtilsException {
  541.         try{
  542.             ContentType contentType = new ContentType(cType);
  543.             String boundaryParam = contentType.getParameter(HttpConstants.CONTENT_TYPE_MULTIPART_PARAMETER_BOUNDARY); 
  544.             if (boundaryParam != null) {
  545.                 return boundaryParam.trim();
  546.             }
  547.             return null;
  548.         } catch (Exception e) {
  549.             throw new UtilsException(e.getMessage(),e);
  550.         }
  551.     }
  552. }
Created with JaCoCo 0.8.8.202204050719