com.daioware.net.http.HttpUtil Maven / Gradle / Ivy

Go to download
package com.daioware.net.http;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.UnsupportedEncodingException;
import java.net.URLDecoder;
import java.util.ArrayList;
import java.util.BitSet;
import java.util.List;

import com.daioware.commons.string.Regex;
import com.daioware.commons.wrapper.WrapperString;

public class HttpUtil {

	public static final String DEFAULT_ENCODING="utf-8";
	
	private static List plainTextMimeTypes=new ArrayList<>(5);
	private static List fileMimeTypes=new ArrayList<>(2);
	private static BitSet safeCharacters;

	private static final char[] hexadecimal =
	  {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
	   'A', 'B', 'C', 'D', 'E', 'F'};

	  static {
	      safeCharacters = new BitSet(256);
	      int i;
	      // 'lowalpha' rule
	      for (i = 'a'; i <= 'z'; i++) {
	          safeCharacters.set(i);
	      }
	      // 'hialpha' rule
	      for (i = 'A'; i <= 'Z'; i++) {
	          safeCharacters.set(i);
	      }
	      // 'digit' rule
	      for (i = '0'; i <= '9'; i++) {
	          safeCharacters.set(i);
	      }

	      // 'safe' rule
	      safeCharacters.set('$');
	      safeCharacters.set('-');
	      safeCharacters.set('_');
	      safeCharacters.set('.');
	      safeCharacters.set('+');

	      // 'extra' rule
	      safeCharacters.set('!');
	      safeCharacters.set('*');
	      safeCharacters.set('\'');
	      safeCharacters.set('(');
	      safeCharacters.set(')');
	      safeCharacters.set(',');

	      // special characters common to http: file: and ftp: URLs ('fsegment' and 'hsegment' rules)
	      safeCharacters.set('/');
	      safeCharacters.set(':');
	      safeCharacters.set('@');
	      safeCharacters.set('&');
	      safeCharacters.set('=');
	  }

	static {
		plainTextMimeTypes.add(new Regex("^text/[\\S]+"));
		plainTextMimeTypes.add(new Regex("application/json"));
		plainTextMimeTypes.add(new Regex("application/javascript"));
		plainTextMimeTypes.add(new Regex("application/xml"));
		plainTextMimeTypes.add(new Regex("application/ecmascript"));

		fileMimeTypes.add(new Regex("^audio/[\\S]+"));
		fileMimeTypes.add(new Regex("^video/[\\S]+"));
		fileMimeTypes.add(new Regex("^image/[\\S]+"));
	}
	
	  /**
	   * Array containing the safe characters set as defined by RFC 1738
	   */
	 

	  /**
	   * Encode a path as required by the URL specification (
	   * RFC 1738). This differs from java.net.URLEncoder.encode() which encodes according
	   * to the x-www-form-urlencoded MIME format.
	   *
	   * @param path the path to encode
	   * @return the encoded path
	   */
	  public static String encodePath(String path) {
	     // stolen from org.apache.catalina.servlets.DefaultServlet ;)

	      /**
	       * Note: Here, ' ' should be encoded as "%20"
	       * and '/' shouldn't be encoded.
	       */

	      int maxBytesPerChar = 10;
	      StringBuffer rewrittenPath = new StringBuffer(path.length());
	      ByteArrayOutputStream buf = new ByteArrayOutputStream(maxBytesPerChar);
	      OutputStreamWriter writer;
	      try {
	          writer = new OutputStreamWriter(buf, "UTF8");
	      } catch (Exception e) {
	          e.printStackTrace();
	          writer = new OutputStreamWriter(buf);
	      }

	      for (int i = 0; i < path.length(); i++) {
	          int c = path.charAt(i);
	          if (safeCharacters.get(c)) {
	              rewrittenPath.append((char)c);
	          } else {
	              // convert to external encoding before hex conversion
	              try {
	                  writer.write(c);
	                  writer.flush();
	              } catch(IOException e) {
	                  buf.reset();
	                  continue;
	              }
	              byte[] ba = buf.toByteArray();
	              for (int j = 0; j < ba.length; j++) {
	                  // Converting each byte in the buffer
	                  byte toEncode = ba[j];
	                  rewrittenPath.append('%');
	                  int low = (toEncode & 0x0f);
	                  int high = ((toEncode & 0xf0) >> 4);
	                  rewrittenPath.append(hexadecimal[high]);
	                  rewrittenPath.append(hexadecimal[low]);
	              }
	              buf.reset();
	          }
	      }
	      return rewrittenPath.toString();
	  }

	public static void parseContentType(WrapperString mimeType,WrapperString charset,String headerValue) {
		int s="charset=".length();
		int index=headerValue.indexOf("charset=");
		charset.value=index!=-1?headerValue.substring(index+s):HttpUtil.DEFAULT_ENCODING;
		mimeType.value=index>=0?headerValue.substring(0, index-1):headerValue;
	}

	public static String decodePath(String path,String encoding) throws UnsupportedEncodingException {
		return URLDecoder.decode(path, encoding);
	}
	public static boolean isValid(List regexes,String mimeToCompare) {
		for(Regex currentMime:regexes) {
			if(currentMime.matches(mimeToCompare)) {
				return true;
			}
		}
		return false;
	}
	
	public static boolean isPlainTextMimeType(String mime) {
		boolean b=isValid(plainTextMimeTypes,mime);
		return !b?!isValid(fileMimeTypes,mime):b;
	}
	
}