private void index() throws IOException {
Enumeration entries = _jar.entries();
_nameToEntryMap = new HashMap();
_crcToEntryMap = new HashMap();
_entries = new ArrayList();
if (_debug) {
System.out.println("indexing: " + _jar.getName());
}
if (entries != null) {
while (entries.hasMoreElements()) {
JarEntry entry = (JarEntry) entries.nextElement();
long crc = entry.getCrc();
Long crcL = new Long(crc);
if (_debug) {
System.out.println("\t" + entry.getName() + " CRC " + crc);
}
_nameToEntryMap.put(entry.getName(), entry);
_entries.add(entry);
// generate the CRC to entries map
if (_crcToEntryMap.containsKey(crcL)) {
// key exist, add the entry to the correcponding
// linked list
// get the linked list
LinkedList ll = (LinkedList) _crcToEntryMap.get(crcL);
// put in the new entry
ll.add(entry);
// put it back in the hash map
_crcToEntryMap.put(crcL, ll);
} else {
// create a new entry in the hashmap for the new key
// first create the linked list and put in the new
// entry
LinkedList ll = new LinkedList();
ll.add(entry);
// create the new entry in the hashmap
_crcToEntryMap.put(crcL, ll);
}
}
}
}
public ArrayList getPointList(long handId) {
ArrayList curList;
if (_pointLists.containsKey(handId)) curList = (ArrayList) _pointLists.get(handId);
else {
curList = new ArrayList(_maxPoints);
_pointLists.put(handId, curList);
}
return curList;
}
void addTextField(JPanel panel, String key, String label) {
JLabel lab = new JLabel(label);
lab.setAlignmentX(LEFT_ALIGNMENT);
panel.add(lab);
JTextField field = new JTextField();
field.setText(sketch.configFile.get(key));
field.setMaximumSize(new Dimension(Integer.MAX_VALUE, field.getPreferredSize().height));
fields.put(key, field);
panel.add(field);
}
void addTextArea(JPanel panel, String key, String label) {
JLabel lab = new JLabel(label);
lab.setAlignmentX(LEFT_ALIGNMENT);
panel.add(lab);
JTextArea field = new JTextArea();
field.setText(sketch.configFile.get(key));
field.setLineWrap(true);
field.setWrapStyleWord(true);
fields.put(key, field);
JScrollPane scroll = new JScrollPane(field);
scroll.setAlignmentX(0.0f);
panel.add(scroll);
}
public void init(FilterConfig filterConfig) {
this.config = filterConfig;
this.encoding = config.getInitParameter("encoding");
if (encoding == null || encoding.length() == 0) {
encoding = "GBK";
}
expiresMap = new HashMap();
Enumeration names = config.getInitParameterNames();
while (names.hasMoreElements()) {
String paramName = (String) names.nextElement();
if (!"encoding".equals(paramName)) {
String paramValue = config.getInitParameter(paramName);
try {
Integer expires = Integer.valueOf(config.getInitParameter(paramName));
expiresMap.put(paramName, expires);
} catch (Exception ex) {
// LogUtil.logError( "Filter."+paramValue+"="+paramValue);
}
}
}
}
/** Creates a patch from the two passed in files, writing the result to <code>os</code>. */
public static void createPatch(String oldPath, String newPath, OutputStream os, boolean minimal)
throws IOException {
JarFile2 oldJar = new JarFile2(oldPath);
JarFile2 newJar = new JarFile2(newPath);
try {
Iterator entries;
HashMap moved = new HashMap();
HashSet visited = new HashSet();
HashSet implicit = new HashSet();
HashSet moveSrc = new HashSet();
HashSet newEntries = new HashSet();
// FIRST PASS
// Go through the entries in new jar and
// determine which files are candidates for implicit moves
// ( files that has the same filename and same content in old.jar
// and new.jar )
// and for files that cannot be implicitly moved, we will either
// find out whether it is moved or new (modified)
entries = newJar.getJarEntries();
if (entries != null) {
while (entries.hasNext()) {
JarEntry newEntry = (JarEntry) entries.next();
String newname = newEntry.getName();
// Return best match of contents, will return a name match if possible
String oldname = oldJar.getBestMatch(newJar, newEntry);
if (oldname == null) {
// New or modified entry
if (_debug) {
System.out.println("NEW: " + newname);
}
newEntries.add(newname);
} else {
// Content already exist - need to do a move
// Should do implicit move? Yes, if names are the same, and
// no move command already exist from oldJar
if (oldname.equals(newname) && !moveSrc.contains(oldname)) {
if (_debug) {
System.out.println(newname + " added to implicit set!");
}
implicit.add(newname);
} else {
// The 1.0.1/1.0 JarDiffPatcher cannot handle
// multiple MOVE command with same src.
// The work around here is if we are going to generate
// a MOVE command with duplicate src, we will
// instead add the target as a new file. This way
// the jardiff can be applied by 1.0.1/1.0
// JarDiffPatcher also.
if (!minimal && (implicit.contains(oldname) || moveSrc.contains(oldname))) {
// generate non-minimal jardiff
// for backward compatibility
if (_debug) {
System.out.println("NEW: " + newname);
}
newEntries.add(newname);
} else {
// Use newname as key, since they are unique
if (_debug) {
System.err.println("moved.put " + newname + " " + oldname);
}
moved.put(newname, oldname);
moveSrc.add(oldname);
}
// Check if this disables an implicit 'move <oldname> <oldname>'
if (implicit.contains(oldname) && minimal) {
if (_debug) {
System.err.println("implicit.remove " + oldname);
System.err.println("moved.put " + oldname + " " + oldname);
}
implicit.remove(oldname);
moved.put(oldname, oldname);
moveSrc.add(oldname);
}
}
}
}
} // if (entries != null)
// SECOND PASS: <deleted files> = <oldjarnames> - <implicitmoves> -
// <source of move commands> - <new or modified entries>
ArrayList deleted = new ArrayList();
entries = oldJar.getJarEntries();
if (entries != null) {
while (entries.hasNext()) {
JarEntry oldEntry = (JarEntry) entries.next();
String oldName = oldEntry.getName();
if (!implicit.contains(oldName)
&& !moveSrc.contains(oldName)
&& !newEntries.contains(oldName)) {
if (_debug) {
System.err.println("deleted.add " + oldName);
}
deleted.add(oldName);
}
}
}
// DEBUG
if (_debug) {
// DEBUG: print out moved map
entries = moved.keySet().iterator();
if (entries != null) {
System.out.println("MOVED MAP!!!");
while (entries.hasNext()) {
String newName = (String) entries.next();
String oldName = (String) moved.get(newName);
System.out.println("key is " + newName + " value is " + oldName);
}
}
// DEBUG: print out IMOVE map
entries = implicit.iterator();
if (entries != null) {
System.out.println("IMOVE MAP!!!");
while (entries.hasNext()) {
String newName = (String) entries.next();
System.out.println("key is " + newName);
}
}
}
JarOutputStream jos = new JarOutputStream(os);
// Write out all the MOVEs and REMOVEs
createIndex(jos, deleted, moved);
// Put in New and Modified entries
entries = newEntries.iterator();
if (entries != null) {
while (entries.hasNext()) {
String newName = (String) entries.next();
if (_debug) {
System.out.println("New File: " + newName);
}
writeEntry(jos, newJar.getEntryByName(newName), newJar);
}
}
jos.finish();
jos.close();
} catch (IOException ioE) {
throw ioE;
} finally {
try {
oldJar.getJarFile().close();
} catch (IOException e1) {
// ignore
}
try {
newJar.getJarFile().close();
} catch (IOException e1) {
// ignore
}
} // finally
}
private void readRecord(int recordSize) throws IOException {
int uid = PdbUtil.readShort(myStream);
if (uid == 1) {
myCompressionVersion = (short) PdbUtil.readShort(myStream);
} else {
int paragraphs = PdbUtil.readShort(myStream);
int size = PdbUtil.readShort(myStream);
// TODO ??????
int type = myStream.read();
int flags = myStream.read();
switch (type) {
case 0: // text (TODO: found sample file and test this code)
case 1: // compressed text
{
ArrayList /*<Integer>*/ pars = new ArrayList();
for (int i = 0; i < paragraphs; ++i) {
int pSize = PdbUtil.readShort(myStream);
pars.add(pSize);
myStream.skip(2);
}
boolean doProcess = false;
if (type == 0) { // ?
byte[] buf = new byte[size];
doProcess = myStream.read(buf, 0, (int) size) == size;
if (doProcess) {
// TODO: use encoding!!!!
// TODO: don't create any new objects!!!!
myCharBuffer = new String(buf).toCharArray();
}
} else if (myCompressionVersion == 1) {
byte[] buf = new byte[size];
doProcess =
DocDecompressor.decompress(myStream, buf, recordSize - 8 - 4 * paragraphs)
== size;
if (doProcess) {
myCharBuffer = new String(buf).toCharArray();
}
} else if (myCompressionVersion == 2) {
byte input[] = new byte[(int) (recordSize - 10 - 4 * paragraphs)];
final int inputSize = myStream.read(input);
Inflater decompressor = new Inflater();
decompressor.setInput(input, 0, inputSize);
byte output[] = new byte[size];
try {
doProcess = decompressor.inflate(output) == size;
decompressor.end();
myCharBuffer = new String(output, 0, size).toCharArray();
} catch (DataFormatException e) {
// TODO Auto-generated catch block
// e.printStackTrace();
System.out.println(e.getMessage());
}
// doProcess =
// ZLZDecompressor(recordSize - 10 - 4 * paragraphs).
// decompress(myStream, myCharBuffer, size) == size;
}
if (doProcess) {
addHyperlinkLabel(fromNumber(uid));
myParagraphMap.put(uid, new ArrayList());
myParagraphVector = (ArrayList) myParagraphMap.get(uid);
processTextRecord(size, pars);
if ((flags & 0x1) == 0) {
// insertEndOfTextParagraph();
// setNewTextModel();
}
}
break;
}
case 2: // image
case 3: // compressed image
{
final String mime = "image/palm";
ZLImage image = null;
if (type == 2) {
System.out.println("non-compressed image");
image = new PluckerFileImage(mime, myFile, myStream.offset(), recordSize - 8);
} else if (myCompressionVersion == 1) {
System.out.println("DocCompressedImage");
image = new DocCompressedFileImage(mime, myFile, myStream.offset(), recordSize - 8);
} else if (myCompressionVersion == 2) {
System.out.println("ZCompressedImage");
image =
new ZCompressedFileImage(mime, myFile, myStream.offset() + 2, recordSize - 10);
}
if (image != null) {
addImage(fromNumber(uid), image);
}
break;
}
case 9: // category record is ignored
break;
case 10:
short typeCode = (short) PdbUtil.readShort(myStream);
break;
case 11: // style sheet record is ignored
break;
case 12: // font page record is ignored
break;
case 13: // TODO: process tables
case 14: // TODO: process tables
break;
case 15: // multiimage
{
short columns = (short) PdbUtil.readShort(myStream);
short rows = (short) PdbUtil.readShort(myStream);
System.out.println("multiimage");
/*PluckerMultiImage image = new PluckerMultiImage(rows, columns, Model.getImageMap());
for (int i = 0; i < size / 2 - 2; ++i) {
short us = (short)myStream.read();
PdbUtil.readShort(myStream, us);
image.addId(fromNumber(us));
}
addImage(fromNumber(uid), image);
*/ break;
}
default:
// std::cerr << "type = " << (int)type << "\n";
break;
}
}
}
/* -------------------------------------------------------------------------------------------------------
This method:
-- Takes in three paramters:
1. array - this is the byte array that actually holds the document contents
2. md5Hases - holds the entire hash values of the document
3. Divisor1/Divisor2 - main and back up divisor
5. The remainder we are looking for
6/7. min/max boundaries
8. blockFreq - store the block sizes and how many time's they occur
-- We are simply choping up the first file
-------------------------------------------------------------------------------------------------------- */
private static int chopDocument(
byte[] array,
ArrayList<Long> md5Hashes,
long divisor1,
long divisor2,
long divisor3,
long remainder,
long minBoundary,
long maxBoundary,
HashMap<Integer, Integer> blockFreq) {
int documentStart = 0; // used to keep track of where the boundaries are
boolean match = false; // used to ck if we encountered a match
int backUpBreakPoint = -1; // used to store the backup breakpoint
int secondBackUpBreakPoint = -1; // this is the second backup point with the divisor3
StringBuilder builder = new StringBuilder();
int counter = 0;
int i = documentStart + (int) minBoundary - 1; // so we start at the minimum
// loop through all the values in the document
for (; i < md5Hashes.size(); ++i) {
if (md5Hashes.get(i) % divisor1 == remainder) // ck if this equals the mod value
{
int size = i - documentStart + 1; // we only care about the size
if (blockFreq.get(size) == null) // if not in there, then simply store it
blockFreq.put(size, 1);
else // increment it's integer count
blockFreq.put(size, blockFreq.get(size) + 1); // increment the count
counter++; // increment the block count
documentStart = i + 1; // set this as the beginning of the new boundary
backUpBreakPoint = -1; // reset this
secondBackUpBreakPoint = -1; // second backup point reset it!
i = i + (int) minBoundary - 1; // skip all the way here
} else if (md5Hashes.get(i) % divisor2 == remainder) { // check if this is the backup point
backUpBreakPoint = i; // this is the backup breakpoint
} else if (md5Hashes.get(i) % divisor3 == remainder) {
secondBackUpBreakPoint = i; // we found a second backup point with divisor3
}
if ((i - documentStart + 1) >= maxBoundary) { // we have reached the maximum
// ck if we have a backUpbreakpoint
int point;
if (backUpBreakPoint != -1) // if we do, set this as the boundary
point = backUpBreakPoint;
else if (secondBackUpBreakPoint != -1)
point = secondBackUpBreakPoint; // if we don't have a first backup, ck if we have a second
else point = i; // else this current value of i is the breakpoint
// Hash all the values in the range (documentStart,point
// Remember we only want to hash the original VALUES from the array that contains the
// original
// content of the file. Not the hash values in the md5Hash Array
int size = point - documentStart + 1; // we only care about the size
if (blockFreq.get(size) == null) // if not in there, then simply store it
blockFreq.put(size, 1);
else // increment it's integer count
blockFreq.put(size, blockFreq.get(size) + 1); // increment the count
counter++; // increment the block count
documentStart = point + 1; // set this as the beginning of the new boundary
backUpBreakPoint = -1; // reset this
secondBackUpBreakPoint = -1; // reset second backup break point
i = point + (int) minBoundary - 1; // so we start at the minimum
}
} // end of the for loop
// -------------------------------------------------------------------------------------------
// we are missing the last boundary, so hash that last value
// We will also check against our values of the strings we already have, and if we encountered
// this
// already, then we will simply increment the counter, otherwise we will insert it in the
// hashtable
// and increase our miss counter
// ----------------------------------------------------------------------------------------------
int size = array.length - documentStart; // we start from the point
if (blockFreq.get(size) == null) // if not in there, then simply store it
blockFreq.put(size, 1);
else // increment it's integer count
blockFreq.put(size, blockFreq.get(size) + 1); // increment the count
return ++counter; // increment the block count
} // end of the method
/** Update or add a sprite to the client side game. */
public void addPacket(HacktendoPacket Packet) {
while (!getInitialized()) { // Make sure things have loaded before we start mucking with stuff.
try {
Thread.sleep(5);
} catch (Exception e) {
e.printStackTrace();
}
}
do {
Sprite S = (Sprite) Sprites.get(new Integer(Packet.getID()));
boolean setRenderType = false;
if (S == null) {
S = new Sprite(this);
setRenderType = true;
S.setParameter("destroy", new TypeBoolean(false));
S.setParameter("globalID", new TypeInteger(Packet.getID()));
S.setParameter("id", new TypeInteger(Packet.getID()));
Sprites.put(new Integer(Packet.getID()), S);
S.setOffscreenProcessing(false);
}
S.setScriptID(Packet.getScriptID());
S.setImageID(Packet.getImage());
if (S.getSpriteID() != playerID || setRenderType) { // Allow the sprite to move client side.
S.setX(Packet.getX());
S.setY(Packet.getY());
S.setZ(Packet.getZ());
S.setParameter("xTarget", new TypeInteger(Packet.getTargetX()));
S.setParameter("yTarget", new TypeInteger(Packet.getTargetY()));
S.setParameter("newTarget", new TypeBoolean(true));
}
if (Packet.getExplodeSprite()) S.explode();
if (Packet.getDestroySprite()) S.setParameter("destroy", new TypeBoolean(true));
S.setFrame(Packet.getFrame());
S.setXRotation(Packet.getXRotation());
S.setYRotation(Packet.getYRotation());
S.setZRotation(Packet.getZRotation());
S.setWidth(Packet.getWidth());
S.setHeight(Packet.getHeight());
S.setDepth(Packet.getDepth());
S.setZOffset(Packet.getZOffset() * -1);
if (setRenderType) S.setRenderType(Packet.getRenderType());
} while (Packet.next() > 0);
// Takes the form Object[]{ID,IP,Name,NPC,BODY_ID}
if (Packet.getReferenceArray() != null) {
for (int i = 0; i < Packet.getReferenceArray().size(); i++) {
Object O[] = (Object[]) Packet.getReferenceArray().get(i);
Sprite S = (Sprite) Sprites.get((Integer) O[0]);
System.out.println("ID: " + O[0]);
if (S != null) {
String ip = (String) O[1];
String name = (String) O[2];
boolean npc = (Boolean) O[3];
S.setParameter("ip", new TypeString(ip));
S.setParameter("name", new TypeString(name));
S.setParameter("npc", new TypeBoolean(npc));
if (S.getScriptID() == SPRITE_SCRIPT) {
S.setOffscreenProcessing(true);
S.setAutoCollide(true);
Sprite S2 = (Sprite) Sprites.get((Integer) O[4]);
S.setParameter("body", new TypeInteger(S2.getSpriteID()));
}
if (ip.equals(MyHacker.getIP())) {
if (S.getScriptID() == SPRITE_SCRIPT) {
playerSprite = S;
}
playerID = S.getSpriteID();
System.out.println(
"We are setting the player to equal : "
+ S.getSpriteID()
+ " This Is Sprite ID: "
+ O[0]);
HacktendoLinker.addGlobal("player", new TypeInteger(S.getSpriteID()));
}
}
}
}
}
