/**********************************************************************************
*
* Copyright (c) 2003, 2004, 2007, 2008 The Sakai Foundation
*
* Licensed under the Educational Community License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.opensource.org/licenses/ECL-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
**********************************************************************************/
package edu.indiana.lib.twinpeaks.util;
import java.io.*;
import java.net.*;
import java.util.*;
import javax.servlet.*;
import javax.servlet.http.*;
/**
* HTTP utilites
*/
public class HttpTransactionUtils
{
private static org.apache.commons.logging.Log _log = LogUtils.getLog(HttpTransactionUtils.class);
private HttpTransactionUtils() {
}
/**
* Default HTTP character set
*/
public static final String DEFAULTCS = "ISO-8859-1";
/*
* Parameter handling
*/
/**
* Format one HTTP parameter
* @param name Parameter name
* @param value Parameter value (URLEncoded using default chracter set)
* @return Parameter text (ampersand+name=url-encoded-value)
*/
public static String formatParameter(String name, String value) {
return formatParameter(name, value, "&", DEFAULTCS);
}
/**
* Format one HTTP parameter
* @param name Parameter name
* @param value Parameter value (will be URLEncoded)
* @param separator Character to separate parameters
* @param cs Character set specification (utf-8, etc)
* @return Parameter text (separator+name=url-encoded-value)
*/
public static String formatParameter(String name, String value,
String separator, String cs) {
StringBuilder parameter = new StringBuilder();
if (!StringUtils.isNull(value)) {
parameter.append(separator);
parameter.append(name);
parameter.append('=');
try {
parameter.append(URLEncoder.encode(value, cs));
} catch (UnsupportedEncodingException exception) {
throw new IllegalArgumentException("Invalid character set: \""
+ cs
+ "\"");
}
}
return parameter.toString();
}
/*
* HTTP status values
*/
/**
* Informational status?
* @return true if so
*/
public static boolean isHttpInfo(int status) {
return ((status / 100) == 1);
}
/**
* HTTP redirect?
* @return true if so
*/
public static boolean isHttpRedirect(int status) {
return ((status / 100) == 3);
}
/**
* Success status?
* @return true if so
*/
public static boolean isHttpSuccess(int status) {
return ((status / 100) == 2);
}
/**
* Error in request?
* @return true if so
*/
public static boolean isHttpRequestError(int status) {
return ((status / 100) == 4);
}
/**
* Server error?
* @return true if so
*/
public static boolean isHttpServerError(int status) {
return ((status / 100) == 5);
}
/**
* General "did an error occur"?
* @return true if so
*/
public static boolean isHttpError(int status) {
return isHttpRequestError(status) || isHttpServerError(status);
}
/**
* Set up a simple Map of HTTP request parameters (assumes no duplicate names)
* @param request HttpServletRequest object
* @return Map of name=value pairs
*/
public static Map getAttributesAsMap(HttpServletRequest request) {
Enumeration enumeration = request.getParameterNames();
HashMap map = new HashMap();
while (enumeration.hasMoreElements()) {
String name = (String) enumeration.nextElement();
map.put(name, request.getParameter(name));
}
return map;
}
/**
* Format a base URL string ( protocol://server[:port] )
* @param url URL to format
* @return URL string
*/
public static String formatUrl(URL url) throws MalformedURLException {
return formatUrl(url, false);
}
/**
* Format a base URL string ( protocol://server[:port][/file-specification] )
* @param url URL to format
* @param preserveFile Keep the /directory/filename portion of the URL?
* @return URL string
*/
public static String formatUrl(URL url, boolean preserveFile)
throws MalformedURLException {
StringBuilder result;
int port;
result = new StringBuilder(url.getProtocol());
result.append("://");
result.append(url.getHost());
if ((port = url.getPort()) != -1) {
result.append(":");
result.append(String.valueOf(port));
}
if (preserveFile) {
String file = url.getFile();
if (file != null) {
result.append(file);
}
}
return result.toString();
}
/**
* Pull the server [and port] from a URL specification
* @param url URL string
* @return server[:port]
*/
public static String getServer(String url) {
String server = url;
int protocol, slash;
if ((protocol = server.indexOf("//")) != -1) {
if ((slash = server.substring(protocol + 2).indexOf("/")) != -1) {
server = server.substring(0, protocol + 2 + slash);
}
}
return server;
}
/*
* urlEncodeParameters(): URL component specifications
*/
/**
* protocol://server
*/
public static final String SERVER = "server";
/**
* /file/specification
*/
public static final String FILE = "file";
/**
* ?parameter1=value1¶meter2=value2
*/
public static final String PARAMETERS = "parameters";
/**
* /file/specification?parameter1=value1¶meter2=value2
*/
public static final String FILEANDPARAMS = "fileandparameters";
/**
* Fetch a component from a URL string
* @param url URL String
* @param component name (one of server, file, parameters, fileandparameters)
* @return URL component string (null if none)
*/
public static String getUrlComponent(String url, String component)
throws MalformedURLException {
String file;
int index;
if (component.equalsIgnoreCase(SERVER)) {
return getServer(url);
}
if (!component.equalsIgnoreCase(FILE) &&
!component.equalsIgnoreCase(PARAMETERS) &&
!component.equalsIgnoreCase(FILEANDPARAMS)) {
throw new IllegalArgumentException(component);
}
file = new URL(url).getFile();
if (file == null) {
return null;
}
/*
* Fetch file and parameters?
*/
if (component.equalsIgnoreCase(FILEANDPARAMS)) {
return file;
}
/*
* File portion only?
*/
index = file.indexOf('?');
if (component.equalsIgnoreCase(FILE)) {
switch (index) {
case -1: // No parameters
return file;
case 0: // Only parameters (no file)
return null;
default:
return file.substring(0, index);
}
}
/*
* Isolate parameters
*/
return (index == -1) ? null : file.substring(index);
}
/**
* URLEncode parameter names and values
* @param original Full URL specification (http://example.com/xxx?a=b&c=d)
* @return Original URL with (possibly) encoded parameters
*/
public static String urlEncodeFullUrl(String original) {
StringBuilder encoded;
String base, file, params;
try {
base = getUrlComponent(original, SERVER);
file = getUrlComponent(original, FILE);
params = getUrlComponent(original, PARAMETERS);
} catch (MalformedURLException exception) {
_log.warn("Invalid URL provided: " + original);
return original;
}
if (StringUtils.isNull(params)) {
return original;
}
encoded = new StringBuilder();
encoded.append(base);
if (!StringUtils.isNull(file)) {
encoded.append(file);
}
encoded.append(urlEncodeParameters(params));
return encoded.toString();
}
/**
* URLEncode parameter names and values
* @param original Original parameter list (?a=b&c=d)
* @return Possibly encoded parameter list
*/
public static String urlEncodeParameters(String original) {
StringBuilder encoded = new StringBuilder();
for (int i = 0; i < original.length(); i++) {
String c = original.substring(i, i + 1);
if (!c.equals("&") && !c.equals("=") && !c.equals("?")) {
c = URLEncoder.encode(c);
}
encoded.append(c);
}
return encoded.toString();
}
/*
* Test
*/
public static void main(String[] args) throws Exception {
String u = "http://example.com/dir1/dir2/file.html?parm1=1¶m2=2";
System.out.println("Server: " + getUrlComponent(u, "server"));
System.out.println("File: " + getUrlComponent(u, "file"));
System.out.println("Parameters: " + getUrlComponent(u, "parameters"));
System.out.println("File & Parameters: " + getUrlComponent(u, "fileandparameters"));
System.out.println("Bad: " + getUrlComponent(u, "bad"));
}
}