/** Servlet initialization. */
public void init(ServletConfig config) throws ServletException {
super.init(config);
try {
// Initialize all the internal parameters from the supplied info in the
// web descriptor file
System.out.println("Reading parameters specified in the web.xml descriptor file");
initParams(config);
// initialize local logger
logger = MPILogger.getLogger(AuthenticatorServlet.class.getName());
// load WaitUntilFirstReqeust property
String wufr =
(String)
Config.getConfigReference()
.getConfigData(MPIConfigDefinition.WAIT_UNTIL_FIRST_REQUEST);
if ((wufr != null) && (wufr.equalsIgnoreCase("true"))) {
logger.debug("CardRangeMonitor initialization waits until first request.");
AuthenticatorServlet.waitUntilFirstRequest = true;
} else {
logger.debug("Start CardRangeMonitor initialization.");
AuthenticatorServlet.waitUntilFirstRequest = false;
initCRMonitor();
}
/*
* Then initialize the proper connection parameters
*/
boolean initialOK = SecurityManager.getInstance().initializeConnection();
if (!initialOK) {
this.logger.error("Failed to initialize connection parameters.");
}
/*
* [Jun's Note - Dec 04, 2002]
* JMX agent initialization
*/
CoreAgentManager.initAgent();
/*
* Indicate that initialization is OK and we are ready to accept requests
*/
System.out.println(
"- - - - Verified@ONCE Core Server component is open for e-business - - - -");
} catch (ConfigurationException ce) {
logger.error(
"Failed to load config property. WaitUntilFirstRequest property set to 'true' as default.",
ce);
AuthenticatorServlet.waitUntilFirstRequest = true;
} catch (CoreAgentException cae) {
logger.error("Jmx Agent Starting Error: ", cae);
}
}
/**
* Description: This thread is resposible for sending error message back to VisaDir or ACS when MPI
* receives invalid VERes or PARes message
*
* @version 0.1 Oct 18, 2002
* @author Jerome Mourits
*/
public class ErrorHandlerThread extends Thread {
private Logger logger = MPILogger.getLogger(ErrorHandlerThread.class.getName());
private Vector toBeSent = new Vector();
private static int interval;
public void run() {
setInterval(ErrorHandlerThreadManager.getErrorThreadSleepInterval());
// this is not correct should be changed later
// - only shut down when the server is shutdown
while (true) {
if (ErrorHandlerThreadManager.getErrorVector().size() > 0) {
synchronized (ErrorHandlerThreadManager.lock) {
toBeSent = new Vector(ErrorHandlerThreadManager.getErrorVector());
ErrorHandlerThreadManager.setErrorVector(new Vector());
}
}
if (toBeSent.size() > 0) {
logger.debug("Process error requests: " + toBeSent.size());
for (int i = 0; i < toBeSent.size(); i++) {
logger.debug("process error request " + i + "...");
ErrorRequest er = (ErrorRequest) toBeSent.get(i);
send(er.getToUrl(), er.getMsg());
logger.debug("process error request " + i + " finished.");
}
toBeSent = new Vector();
} else {
logger.debug("No ErrorRequest to be processed.");
}
try {
sleep(getInterval());
} catch (InterruptedException e) {
logger.debug("ErrorHandlerThread interrupted by other thread.", e);
}
}
}
// start sending to targetUrl ....
private void send(String targetUrl, Message sentMsg) {
// do logging
logger.debug("ErrorHandlerThread is called");
// Initialize IO stream
OutputStreamWriter out = null;
try {
// Precheck id
if ((sentMsg.getId() != null) && (sentMsg.getId().equals("UNKNOWN"))) {
sentMsg.setId(ID_Generator.getUniqueId());
logger.debug("UNKNOWN id replaced with new id: " + sentMsg.getId());
}
logger.debug("Sending message to targetUrl: " + targetUrl);
/**
* The following change done by Gang, to change the HttpConnection to directly use SUN
* implementation
*/
/**
* The following old one is replaced //Establish connection to servlet URL url = new
* URL(targetUrl);
*/
// Establish connection to servlet
URL url;
if (targetUrl != null && targetUrl.trim().toLowerCase().startsWith("https:"))
url = new URL(null, targetUrl, new Handler());
else url = new URL(targetUrl);
URLConnection conn = url.openConnection();
logger.debug("connection setup finished.");
// Prepare for both input and output
conn.setDoInput(true);
conn.setDoOutput(true);
// Turn off caching
conn.setUseCaches(false);
// Convert inMsg to string
String msg = sentMsg.toString();
logger.debug("Content to targetUrl: " + msg);
// Set content type to MPI message
conn.setRequestProperty("Content-Type", "application/xml; charset=\"utf-8\"");
// Set content length
conn.setRequestProperty("Content-Length", Integer.toString(msg.length()));
// Create output stream
out = new OutputStreamWriter(conn.getOutputStream());
// Write message as POST data
// out.write(URLEncoder.encode(msg));
out.write(msg);
// Flush it
out.flush();
// Close output stream
out.close();
logger.debug("Sending finished.");
// prepare for logging
Date timestamp = Calendar.getInstance().getTime();
// check the response
if ((conn instanceof HttpURLConnection) || (conn instanceof HttpsURLConnection)) {
int i;
// get Response Code
if (conn instanceof HttpURLConnection) {
HttpURLConnection ht = (HttpURLConnection) conn;
i = ht.getResponseCode();
} else {
HttpsURLConnection hts = (HttpsURLConnection) conn;
i = hts.getResponseCode();
}
// logging handling
if (i == 200) {
// do logging
logger.debug(
"Error Message (id ="
+ sentMsg.getId()
+ ") is sent to targetUrl: ["
+ targetUrl
+ "] successfully - Time At: ["
+ timestamp.toString()
+ "]");
} else {
// do logging
logger.error(
"Error Message (id ="
+ sentMsg.getId()
+ ") cannot be sent back to targetUrl: ["
+ targetUrl
+ "] - Time At: ["
+ timestamp.toString()
+ "]");
}
} else {
logger.error("NO HTTP connection was set up");
}
} catch (Exception e) {
logger.error("Failed to send error message to targetUrl, Reason: " + e.getMessage(), e);
} finally {
try {
if (out != null) out.close();
} catch (Exception e) {
logger.error("Couldn't close outputstream in ErrorHandlerThread finally block.", e);
}
}
}
/**
* Returns the interval.
*
* @return int
*/
public static int getInterval() {
return interval;
}
/**
* Sets the interval.
*
* @param interval The interval to set
*/
public static void setInterval(int interval) {
ErrorHandlerThread.interval = interval;
}
}
/** * This class is a utility class that provides Base64 conversion to several different format, * namely: - Binary - Binhex - Asciihex * * <p>This conversion is used with the PARes.CAVV and the PARes.xid values to accomodate merchant * application that must submit those values using a different format than the standard "base64" * one. * * @author Martin Dufort ([email protected]) */ public class Base64Conversion { /** Local Log4J logger */ private static Logger logger = MPILogger.getLogger(Base64Conversion.class.getName()); /* Definition of the available conversion functions */ public static final String TO_BASE64 = "ToBase64"; public static final String TO_BINARY = "ToBinary"; public static final String TO_BINHEX = "ToBinHex"; public static final String TO_ASCIIHEX = "ToAsciiHex"; /** * Convert a Base64 value into one of the other available formats * * @param in Value to be converted * @param format Format to convert the value to * @return Properly converted value */ public static String convert(String in, String format) throws IllegalArgumentException { logger.debug("Converting Base64 value: " + in + " to new format: " + format); // If the format is unknown or we are requesting a Base64 format, then we // return the value as is... if ((format == null) || (format.equalsIgnoreCase(TO_BASE64))) { return in; } // Decode value first byte[] res = Base64Codec.decode(in); if (res == null) { // Unable to decode, probabling garbled characters return null; } // Conversion to a binary format ??? if (format.equalsIgnoreCase(TO_BINARY)) { // Binary format is just returning the decoded value as a String return toBinary(res); } // // ***** Not Supported for now!!!! ***** // else if (format.equalsIgnoreCase(TO_BINHEX)) { // // To Binary hex format // /* // * [Martin's Note: 21-May-03 11:14:40 AM] // * // * not currently supported. return the value as B64 // */ // /* return toBinhex(res); */ // return in; // } else if (format.equalsIgnoreCase(TO_ASCIIHEX)) { // To ASCII Hex format return toAsciiHex(res); } else { // Unknown format wanted. we send back as original logger.debug( "Unknown conversion format " + format + " specified for Base64 Conversion.\nReturning original value"); return in; // throw new IllegalArgumentException("Unknown conversion format " + format + " specified for // Base64 Conversion."); } } /** * Return the binary version of the Base64 value. Since the input is already base64 decoded we * just create a String with the supplied byte array and return it as our result. * * @param value Value to be converted * @return String represnting the binary representation */ private static String toBinary(byte[] value) { return new String(value); } /** * Return the binhex version of the base64 value supplied. This conversion operation is based on * the algorithm found in Python 2.2.1 library and is and adaption of it. Please refer to: * <href>http://www.python.org/doc/current/lib/module-binascii.html</href> for more information * * @param value Value to be converted * @return String representing the binhex representation */ private static String toBinhex(byte[] value) { /* * [Martin's Note: 25-Apr-03 9:16:00 AM] * * The only implementation of the BinHex algorithm I found is related to the * Macintosh and published by Peter Lewis. I'm not sure we should support that * conversion format because it is not readily available. The implementation is * postponed for now....... * * Come and see me if you have a problem with this.... */ return null; } /** * Return the hexadecimal representation of the binary data. Every byte of data is converted into * the corresponding 2-digit hex representation. The resulting string is therefore twice as long * as the length of data * * @param value Value to be converted * @return String representing the ASCIIHex version of the value */ private static String toAsciiHex(byte[] value) { // Define the hexadecimal alphabet here... char[] hexAlphabet = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' }; StringBuffer hexResult = new StringBuffer(); for (int idx = 0; idx < value.length; idx++) { // All values are made up of 2 characters, so check both. int currentValue = value[idx]; int bigEndian = currentValue >> 4; int smallEndian = currentValue - (bigEndian * 16); // Add both hex values to our string hexResult.append(hexAlphabet[bigEndian]); hexResult.append(hexAlphabet[smallEndian]); } // Return our string result containing the hex value return hexResult.toString(); } }