LegacyConsole/jpexs-decompiler
2
0
Fork 0
mirror of https://git.huckle.dev/Huckles-Minecraft-Archive/jpexs-decompiler.git synced 2026-05-24 07:36:11 +00:00
Code Issues Packages Projects Releases Wiki Activity

Removed: Proxy feature. It was not working since today almost every page uses HTTPS. Also Flash is limited in browsers.

Browse Source
This commit is contained in:
Jindra Petřík
2024-08-02 17:05:30 +02:00
parent a526fbe74a
commit 449f96942e
47 changed files with 6 additions and 5877 deletions
Download Patch File Download Diff File Expand all files Collapse all files

158
libsrc/jpproxy/build.xml
View File

@@ -1,158 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<project name="JPProxy" default="build" basedir=".">
<description>Builds project JPProxy.</description>
<import file="buildconfig.xml"/>
<property name="DISTLIBRARIESFULLDIR" value="${DISTRIBUTIONDIR}/${DISTLIBRARIESDIR}"/>
<property name="JAVADOCFULLDIR" value="${DISTRIBUTIONDIR}/${JAVADOCDIR}"/>
<patternset id="compiler.resources">
<include name="**/?*.properties"/>
<include name="**/?*.bin"/>
<include name="**/?*.xml"/>
<include name="**/?*.txt"/>
<include name="**/?*.gif"/>
<include name="**/?*.png"/>
<include name="**/?*.jpeg"/>
<include name="**/?*.jpg"/>
<include name="**/?*.html"/>
<include name="**/?*.dtd"/>
<include name="**/?*.tld"/>
<include name="**/?*.mid"/>
<include name="**/?*.wav"/>
</patternset>
<path id="emma.lib">
<pathelement location="${TESTLIBDIR}/emma.jar"/>
<pathelement location="${TESTLIBDIR}/emma_ant.jar"/>
</path>
<taskdef resource="emma_ant.properties" classpathref="emma.lib"/>
<target name="coverage.instrumentation">
<mkdir dir="${INSTRDIR}"/>
<mkdir dir="${COVERAGEDIR}"/>
<emma>
<instr instrpath="${COMPILEDIR}" destdir="${INSTRDIR}" metadatafile="${COVERAGEDIR}/metadata.emma"
mode="copy"></instr>
</emma>
<copy todir="${INSTRDIR}">
<fileset dir="${SOURCEDIR}">
<patternset refid="compiler.resources"/>
<type type="file"/>
</fileset>
</copy>
</target>
<target name="compile">
<delete dir="${COMPILEDIR}"/>
<mkdir dir="${COMPILEDIR}"/>
<javac srcdir="${SOURCEDIR}" destdir="${COMPILEDIR}" includes="**/*.java" target="1.6" debug="true"
debuglevel="lines,vars,source">
<classpath>
<fileset dir="${LIBRARIESDIR}" includes="**/*.jar"/>
</classpath>
</javac>
<copy todir="${COMPILEDIR}">
<fileset dir="${SOURCEDIR}">
<patternset refid="compiler.resources"/>
<type type="file"/>
</fileset>
</copy>
</target>
<target name="test" depends="clean,compile">
<delete dir="${TESTRESULTSDIR}"/>
<mkdir dir="${TESTRESULTSDIR}"/>
<mkdir dir="${TESTRESULTSDIR}/raw/"/>
<delete dir="${COMPILETESTSDIR}"/>
<mkdir dir="${COMPILETESTSDIR}"/>
<javac srcdir="${TESTDIR}" destdir="${COMPILETESTSDIR}" includes="**/*.java" target="1.6">
<classpath>
<pathelement path="${COMPILEDIR}"/>
<fileset dir="${LIBRARIESDIR}" includes="**/*.jar"/>
<fileset dir="${TESTLIBDIR}" includes="**/*.jar"/>
</classpath>
</javac>
<antcall target="coverage.instrumentation"/>
<junit printsummary="yes" haltonfailure="yes" showoutput="yes">
<classpath>
<pathelement path="${INSTRDIR}"/>
<pathelement path="${COMPILEDIR}"/>
<pathelement path="${COMPILETESTSDIR}"/>
<fileset dir="${LIBRARIESDIR}" includes="**/*.jar"/>
<fileset dir="${TESTLIBDIR}" includes="**/*.jar"/>
</classpath>
<jvmarg value="-Demma.coverage.out.file=${COVERAGEDIR}/coverage.emma"/>
<jvmarg value="-Demma.coverage.out.merge=true"/>
<batchtest fork="yes" todir="${TESTRESULTSDIR}/raw/">
<formatter type="xml"/>
<fileset dir="${TESTDIR}">
<include name="**/*.java"/>
</fileset>
</batchtest>
</junit>
<!-- JUnit report -->
<junitreport todir="${TESTRESULTSDIR}">
<fileset dir="${TESTRESULTSDIR}/raw/">
<include name="TEST-*.xml"/>
</fileset>
<report format="frames" todir="${TESTRESULTSDIR}\html\"/>
</junitreport>
<!-- Coverage report -->
<mkdir dir="${COVERAGERESULTSDIR}"/>
<emma>
<report sourcepath="${SOURCEDIR}" depth="method">
<fileset dir="${COVERAGEDIR}">
<include name="*.emma"/>
</fileset>
<html outfile="${COVERAGERESULTSDIR}/index.html"/>
</report>
</emma>
</target>
<target name="build" depends="clean,compile">
<mkdir dir="${DISTRIBUTIONDIR}"/>
<delete dir="${DISTLIBRARIESFULLDIR}"/>
<mkdir dir="${DISTLIBRARIESFULLDIR}"/>
<copy todir="${DISTLIBRARIESFULLDIR}">
<fileset dir="${LIBRARIESDIR}" includes="**/*.jar"/>
</copy>
<pathconvert pathsep=" " property="manifestClassPath">
<fileset dir="${DISTRIBUTIONDIR}" includes="${DISTLIBRARIESDIR}/**/*.*"/>
<chainedmapper>
<flattenmapper/>
<globmapper from="*" to="${DISTLIBRARIESDIR}/*"/>
</chainedmapper>
</pathconvert>
<jar destfile="${DISTRIBUTIONDIR}/${JARFILENAME}.jar" basedir="${COMPILEDIR}">
<manifest>
<attribute name="Main-Class" value="${MAINCLASS}"/>
<attribute name="Class-Path" value="${manifestClassPath}"/>
</manifest>
</jar>
</target>
<target name="run" depends="build">
<java jar="${DISTRIBUTIONDIR}/${JARFILENAME}.jar" fork="true"/>
</target>
<target name="javadoc">
<mkdir dir="${JAVADOCFULLDIR}"/>
<javadoc sourcepath="${SOURCEDIR}" destdir="${JAVADOCFULLDIR}" windowtitle="${PROJECTNAME}"
useexternalfile="yes">
<fileset dir="${SOURCEDIR}" includes="**/*.java"/>
<classpath>
<fileset dir="${LIBRARIESDIR}" includes="**/*.jar"/>
</classpath>
</javadoc>
</target>
<target name="clean">
<delete dir="${DISTRIBUTIONDIR}"/>
<delete dir="${COMPILETESTSDIR}"/>
<delete dir="${COMPILEDIR}"/>
<delete dir="${COVERAGEDIR}"/>
<delete dir="${TESTRESULTSDIR}"/>
</target>
</project>

23
libsrc/jpproxy/buildconfig.xml
View File

@@ -1,23 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<project name="buildconfig" basedir=".">
<property name="PROJECTNAME" value="JPProxy"/>
<property name="JARFILENAME" value="jpproxy"/>
<property name="MAINCLASS" value="com.jpexs.proxy.Main"/>
<property name="SOURCEDIR" value="src"/>
<property name="TESTDIR" value="test"/>
<property name="TESTLIBDIR" value="testlib"/>
<property name="TESTRESULTSDIR" value="reports/tests"/>
<property name="COVERAGERESULTSDIR" value="reports/coverage"/>
<property name="DISTRIBUTIONDIR" value="dist"/>
<property name="COMPILEDIR" value="build/classes"/>
<property name="INSTRDIR" value="build/instr-classes"/>
<property name="COVERAGEDIR" value="coverage"/>
<property name="COMPILETESTSDIR" value="build/test"/>
<property name="LIBRARIESDIR" value="lib"/>
<property name="DISTLIBRARIESDIR" value="lib"/>
<property name="JAVADOCDIR" value="javadoc"/>
</project>

14
libsrc/jpproxy/jpproxy.iml
View File

@@ -1,14 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<module type="JAVA_MODULE" version="4">
<component name="NewModuleRootManager" inherit-compiler-output="false">
<output url="file://$MODULE_DIR$/build/classes" />
<output-test url="file://$MODULE_DIR$/build/test" />
<exclude-output />
<content url="file://$MODULE_DIR$">
<sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
</content>
<orderEntry type="inheritedJdk" />
<orderEntry type="sourceFolder" forTests="false" />
</component>
</module>

3
libsrc/jpproxy/manifest.mf
View File

@@ -1,3 +0,0 @@
Manifest-Version: 1.0
X-COMMENT: Main-Class will be added automatically by build

73
libsrc/jpproxy/nbbuild.xml
View File

@@ -1,73 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<!-- You may freely edit this file. See commented blocks below for -->
<!-- some examples of how to customize the build. -->
<!-- (If you delete it and reopen the project it will be recreated.) -->
<!-- By default, only the Clean and Build commands use this build script. -->
<!-- Commands such as Run, Debug, and Test only use this build script if -->
<!-- the Compile on Save feature is turned off for the project. -->
<!-- You can turn off the Compile on Save (or Deploy on Save) setting -->
<!-- in the project's Project Properties dialog box.-->
<project name="JPProxy" default="default" basedir=".">
<description>Builds, tests, and runs the project JPProxy.</description>
<import file="nbproject/build-impl.xml"/>
<!--
There exist several targets which are by default empty and which can be
used for execution of your tasks. These targets are usually executed
before and after some main targets. They are:
-pre-init: called before initialization of project properties
-post-init: called after initialization of project properties
-pre-compile: called before javac compilation
-post-compile: called after javac compilation
-pre-compile-single: called before javac compilation of single file
-post-compile-single: called after javac compilation of single file
-pre-compile-test: called before javac compilation of JUnit tests
-post-compile-test: called after javac compilation of JUnit tests
-pre-compile-test-single: called before javac compilation of single JUnit test
-post-compile-test-single: called after javac compilation of single JUunit test
-pre-jar: called before JAR building
-post-jar: called after JAR building
-post-clean: called after cleaning build products
(Targets beginning with '-' are not intended to be called on their own.)
Example of inserting an obfuscator after compilation could look like this:
<target name="-post-compile">
<obfuscate>
<fileset dir="${build.classes.dir}"/>
</obfuscate>
</target>
For list of available properties check the imported
nbproject/build-impl.xml file.
Another way to customize the build is by overriding existing main targets.
The targets of interest are:
-init-macrodef-javac: defines macro for javac compilation
-init-macrodef-junit: defines macro for junit execution
-init-macrodef-debug: defines macro for class debugging
-init-macrodef-java: defines macro for class execution
-do-jar: JAR building
run: execution of project
-javadoc-build: Javadoc generation
test-report: JUnit report generation
An example of overriding the target for project execution could look like this:
<target name="run" depends="JPProxy-impl.jar">
<exec dir="bin" executable="launcher.exe">
<arg file="${dist.jar}"/>
</exec>
</target>
Notice that the overridden target depends on the jar target and not only on
the compile target as the regular run target does. Again, for a list of available
properties which you can use, check the target you are overriding in the
nbproject/build-impl.xml file.
-->
</project>

1402
libsrc/jpproxy/nbproject/build-impl.xml
View File

File diff suppressed because it is too large Load Diff

8
libsrc/jpproxy/nbproject/genfiles.properties
View File

@@ -1,8 +0,0 @@
nbbuild.xml.data.CRC32=0a5363c8
nbbuild.xml.script.CRC32=2eebe506
nbbuild.xml.stylesheet.CRC32=8064a381@1.74.2.48
# This file is used by a NetBeans-based IDE to track changes in generated files such as build-impl.xml.
# Do not edit this file. You may delete it but then the IDE will never regenerate such files for you.
nbproject/build-impl.xml.data.CRC32=0a5363c8
nbproject/build-impl.xml.script.CRC32=6f75ce45
nbproject/build-impl.xml.stylesheet.CRC32=05530350@1.79.1.48

74
libsrc/jpproxy/nbproject/project.properties
View File

@@ -1,74 +0,0 @@
annotation.processing.enabled=true
annotation.processing.enabled.in.editor=false
annotation.processing.run.all.processors=true
annotation.processing.source.output=${build.generated.sources.dir}/ap-source-output
application.title=JPProxy
application.vendor=JPEXS
build.classes.dir=${build.dir}/classes
build.classes.excludes=**/*.java,**/*.form
# This directory is removed when the project is cleaned:
build.dir=build
build.generated.dir=${build.dir}/generated
build.generated.sources.dir=${build.dir}/generated-sources
# Only compile against the classpath explicitly listed here:
build.sysclasspath=ignore
build.test.classes.dir=${build.dir}/test/classes
build.test.results.dir=${build.dir}/test/results
buildfile=nbbuild.xml
# Uncomment to specify the preferred debugger connection transport:
#debug.transport=dt_socket
debug.classpath=\
${run.classpath}
debug.test.classpath=\
${run.test.classpath}
# This directory is removed when the project is cleaned:
dist.dir=dist
dist.jar=${dist.dir}/JPProxy.jar
dist.javadoc.dir=${dist.dir}/javadoc
endorsed.classpath=
excludes=
file.reference.jpproxy-src=src
includes=**
jar.compress=false
javac.classpath=
# Space-separated list of extra javac options
javac.compilerargs=
javac.deprecation=false
javac.processorpath=\
${javac.classpath}
javac.source=1.5
javac.target=1.5
javac.test.classpath=\
${javac.classpath}:\
${build.classes.dir}:\
${libs.junit.classpath}:\
${libs.junit_4.classpath}
javac.test.processorpath=\
${javac.test.classpath}
javadoc.additionalparam=
javadoc.author=false
javadoc.encoding=${source.encoding}
javadoc.noindex=false
javadoc.nonavbar=false
javadoc.notree=false
javadoc.private=false
javadoc.splitindex=true
javadoc.use=true
javadoc.version=false
javadoc.windowtitle=
main.class=com.jpexs.proxy.Main
manifest.file=manifest.mf
meta.inf.dir=${src.dir}/META-INF
platform.active=default_platform
run.classpath=\
${javac.classpath}:\
${build.classes.dir}
# Space-separated list of JVM arguments used when running the project
# (you may also define separate properties like run-sys-prop.name=value instead of -Dname=value
# or test-sys-prop.name=value to set system properties for unit tests):
run.jvmargs=
run.test.classpath=\
${javac.test.classpath}:\
${build.test.classes.dir}
source.encoding=UTF-8
src.dir=${file.reference.jpproxy-src}

13
libsrc/jpproxy/nbproject/project.xml
View File

@@ -1,13 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://www.netbeans.org/ns/project/1">
<type>org.netbeans.modules.java.j2seproject</type>
<configuration>
<data xmlns="http://www.netbeans.org/ns/j2se-project/3">
<name>JPProxy</name>
<source-roots>
<root id="src.dir"/>
</source-roots>
<test-roots/>
</data>
</configuration>
</project>

130
libsrc/jpproxy/src/com/jpexs/proxy/ByteArray.java
View File

@@ -1,130 +0,0 @@
package com.jpexs.proxy;
import java.io.IOException;
import java.io.OutputStream;
public class ByteArray {
public byte[] bytes;
public int offset = 0;
/**
* Create a ByteArray with the default size.
*/
public ByteArray() {
this(512);
}
/**
* Create a ByteArray with a specific default size.
*/
public ByteArray(int size) {
bytes = new byte[size];
}
/**
* Create a ByteArray from a String.
*/
public ByteArray(String s) {
this(s.length());
append(s);
}
/**
* Create a ByteArray from an array of bytes.
*/
public ByteArray(byte[] b) {
this(b.length);
append(b);
}
/**
* Append a byte.
*/
public void append(byte ch) {
if (offset == bytes.length) {
byte[] tmpbytes = bytes;
bytes = new byte[tmpbytes.length * 2];
System.arraycopy(tmpbytes, 0, bytes, 0, offset);
}
bytes[offset++] = ch;
}
/**
* Append a ByteArray.
*/
public void append(ByteArray b) {
if (bytes.length - offset < b.length()) {
byte[] tmpbytes = bytes;
bytes = new byte[tmpbytes.length + b.length()];
System.arraycopy(tmpbytes, 0, bytes, 0, offset);
}
System.arraycopy(b.bytes, 0, bytes, offset, b.length());
offset += b.length();
}
/**
* Append an array of bytes.
*/
public void append(byte[] b) {
if (bytes.length - offset < b.length) {
byte[] tmpbytes = bytes;
bytes = new byte[tmpbytes.length + b.length];
System.arraycopy(tmpbytes, 0, bytes, 0, offset);
}
System.arraycopy(b, 0, bytes, offset, b.length);
offset += b.length;
}
/**
* Append a String.
*/
public void append(String s) {
append(s.getBytes());
}
/**
* Convert to String.
*/
public String toString() {
return new String(bytes, 0, offset);
}
/**
* Return the bytes.
*/
public byte[] getBytes() {
return bytes;
}
public void writeTo(OutputStream out)
throws IOException {
out.write(bytes, 0, offset);
}
public byte get(int i) {
return bytes[i];
}
/**
* Return the number of bytes.
*/
public int length() {
return offset;
}
public void erase() {
offset = 0;
}
public void chop() {
chop(1);
}
public void chop(int i) {
offset -= i;
if (offset < 0) {
offset = 0;
}
}
}

21
libsrc/jpproxy/src/com/jpexs/proxy/CatchedListener.java
View File

@@ -1,21 +0,0 @@
package com.jpexs.proxy;
import java.io.InputStream;
/**
* Interface to catch contentTypes
*
* @author JPEXS
*/
public interface CatchedListener {
/**
* Method called when specified contentType is received
*
* @param contentType Content type
* @param url URL of the method
* @param data Data stream
* @return replacement data
*/
public byte[] catched(String contentType, String url, InputStream data);
}

6
libsrc/jpproxy/src/com/jpexs/proxy/Cleanable.java
View File

@@ -1,6 +0,0 @@
package com.jpexs.proxy;
public interface Cleanable {
public void clean();
}

45
libsrc/jpproxy/src/com/jpexs/proxy/Client.java
View File

@@ -1,45 +0,0 @@
package com.jpexs.proxy;
import java.io.*;
import java.net.Socket;
public class Client extends Connection {
@Override
public void promoteToServerSSL() {
super.promoteToServerSSL();
in = new BufferedInputStream(in);
out = new BufferedOutputStream(out);
}
/**
* Create a Client from a Socket.
*/
Client(Socket s) throws IOException {
super(s);
in = new BufferedInputStream(in);
//out = new DebugOutputStream(new BufferedOutputStream(out));
out = new BufferedOutputStream(out);
}
/**
* Read a Request.
*
* @returns a Request.
* @see Request
*/
Request read() throws IOException {
Request request = new Request(this);
request.read(getInputStream());
return request;
}
/**
* Write a Reply
*
* @see Reply
*/
void write(Reply reply) throws IOException {
reply.write(getOutputStream());
}
}

154
libsrc/jpproxy/src/com/jpexs/proxy/Connection.java
View File

@@ -1,154 +0,0 @@
package com.jpexs.proxy;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.Socket;
import java.net.SocketException;
import java.security.KeyStore;
import java.security.KeyStoreException;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.net.ssl.KeyManagerFactory;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLServerSocketFactory;
import javax.net.ssl.SSLSocket;
import javax.net.ssl.SSLSocketFactory;
class Connection {
Socket socket = null;
InputStream in = null;
OutputStream out = null;
static SSLSocketFactory sf;
static {
String ksName = ProxyConfig.httpsKeyStoreFile;
if (ksName != null) {
char[] ksPass = ProxyConfig.httpsKeyStorePass.toCharArray();
char[] ctPass = ProxyConfig.httpsKeyPass.toCharArray();
try {
KeyStore ks = KeyStore.getInstance("JKS");
ks.load(new FileInputStream(ksName), ksPass);
KeyManagerFactory kmf
= KeyManagerFactory.getInstance("SunX509");
kmf.init(ks, ctPass);
SSLContext sc = SSLContext.getInstance("TLS");
sc.init(kmf.getKeyManagers(), null, null);
sf = sc.getSocketFactory();
} catch (Exception ex) {
}
}
}
public void promoteToClientSSL() {
SSLSocketFactory f = (SSLSocketFactory) SSLSocketFactory.getDefault();
try {
socket = (SSLSocket) f.createSocket(socket, null, socket.getPort(), false);
in = socket.getInputStream();
out = socket.getOutputStream();
} catch (IOException ex) {
}
}
public void promoteToServerSSL() {
try {
socket = sf.createSocket(socket, null, socket.getPort(), false);
((SSLSocket) socket).setUseClientMode(false);
} catch (Exception ex) {
ex.printStackTrace();
}
try {
in = socket.getInputStream();
out = socket.getOutputStream();
} catch (IOException ex) {
}
}
/**
* Create a Connection from a Socket.
*
* @param socket a socket
*/
Connection(Socket socket) throws IOException {
this.socket = socket;
in = socket.getInputStream();
out = socket.getOutputStream();
}
/**
* Create a Connection from a hostname and port.
*
* @param host remote hostname
* @param port remote port
*/
Connection(String host, int port) throws IOException {
this(new Socket(InetAddress.getByName(host), port));
}
Connection() {
}
/**
* Return the input stream.
*/
InputStream getInputStream() {
return in;
}
/**
* Return the output stream.
*/
OutputStream getOutputStream() {
return out;
}
void setInputStream(InputStream in) {
this.in = in;
}
void setOutputStream(OutputStream out) {
this.out = out;
}
/**
* Close the connection.
*/
void close() {
if (socket != null) {
try {
socket.close();
} catch (IOException e) {
}
}
}
public Socket getSocket() {
return socket;
}
public InetAddress getInetAddress() {
return socket.getInetAddress();
}
public int getPort() {
return socket.getPort();
}
public String toString() {
return getInetAddress().getHostAddress() + ":" + getPort();
}
public void setTimeout(int timeout)
throws SocketException {
socket.setSoTimeout(timeout);
}
}

33
libsrc/jpproxy/src/com/jpexs/proxy/Copy.java
View File

@@ -1,33 +0,0 @@
package com.jpexs.proxy;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.IOException;
import java.net.SocketException;
class Copy implements Runnable {
InputStream in = null;
OutputStream out = null;
Copy(InputStream in, OutputStream out) {
this.in = in;
this.out = out;
}
public void run() {
int n;
byte[] buffer = new byte[8192];
try {
while ((n = in.read(buffer, 0, buffer.length)) > 0) {
out.write(buffer, 0, n);
out.flush();
}
out.flush();
} catch (SocketException e) {
} catch (IOException e) {
//Ignore errors
}
}
}

665
libsrc/jpproxy/src/com/jpexs/proxy/Handler.java
View File

@@ -1,665 +0,0 @@
package com.jpexs.proxy;
import java.io.*;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.util.zip.*;
import java.net.Socket;
import java.net.SocketTimeoutException;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.List;
import java.util.Locale;
import java.util.TimeZone;
import javax.net.ssl.SSLHandshakeException;
class Handler implements Runnable {
static final boolean DEBUG = false;
Client client = null;
Socket socket = null;
Request request = null;
Reply reply = null;
HttpRelay http = null;
int currentLength = -1;
int contentLength = -1;
long idle = 0;
double bytesPerSecond = 0;
List<Replacement> replacements;
CatchedListener catchedListener;
List<String> catchedContentTypes;
ReplacedListener replacedListener;
static int curId = 0;
int id;
/**
* Create a Handler.
*/
Handler(Socket socket, List<Replacement> replacements, List<String> catchedContentTypes, CatchedListener catchedListener, ReplacedListener replacedListener) {
curId++;
id = curId;
this.socket = socket;
this.replacements = replacements;
this.catchedListener = catchedListener;
this.catchedContentTypes = catchedContentTypes;
this.replacedListener = replacedListener;
}
/**
* Close all connections associated with this handler.
*/
synchronized void close() {
if (client != null) {
client.close();
client = null;
}
if (http != null) {
http.close();
http = null;
}
}
/**
* Flush all data to the client.
*/
void flush() {
if (client != null) {
try {
client.getOutputStream().flush();
} catch (IOException e) {
}
}
}
public void run() {
boolean keepAlive = false;
Exception reason = null;
Thread.currentThread().setName("Handler("
+ socket.getInetAddress().getHostAddress()
+ ")");
try {
client = new Client(socket);
client.setTimeout(ProxyConfig.readTimeout);
} catch (IOException e) {
return;
}
try {
boolean secure = false;
int securePort = 443;
String secureServer = "";
do {
request = null;
reply = null;
idle = System.currentTimeMillis();
try {
request = client.read();
if (secure) {
request.addSecureHostToURL(secureServer);
}
} catch (SSLHandshakeException she) {
she.printStackTrace();
break;
} catch (IOException e) {
break;
}
if (request.getCommand().equals("CONNECT")) {
secureServer = request.getHost();
securePort = request.getPort();
if ((ProxyConfig.httpsMode == ProxyConfig.HTTPS_FILTER) || ((ProxyConfig.httpsMode == ProxyConfig.HTTPS_FILTERLIST) && (ProxyConfig.enabledHttpsServers.contains(secureServer)))) {
secure = true;
reply = new Reply();
reply.statusLine = "HTTP/1.0 200 Connection established";
reply.setHeaderField("Proxy-agent", ProxyConfig.appName);
try {
client.write(reply);
} catch (IOException ex) {
}
client.promoteToServerSSL();
keepAlive = true;
continue;
}
}
idle = 0;
try {
keepAlive = processRequest(secure, secureServer, securePort);
} catch (IOException ioe) {
reason = ioe;
keepAlive = false;
}
if (request != null && reply != null) {
// XXX insert the number of bytes read into the
// reply content-length for logging.
if (reply != null && currentLength > 0) {
reply.setHeaderField("Content-length", currentLength);
}
}
} while (keepAlive);
} finally {
}
if (reason != null && reason.getMessage().indexOf("Broken pipe") == -1) {
if (client != null && request != null) {
error(client.getOutputStream(), reason, request);
}
}
close();
}
boolean processRequest(boolean secure, String secureHost, int securePort) throws IOException {
boolean keepAlive = false;
while (reply == null) {
//boolean secure = false;
boolean uncompress = false;
if (request.getCommand().equals("CONNECT")) {
secure = true;
} else if (request.getURL().startsWith("/")) {
} else if (request.getURL().startsWith("https://") && (secure)) {
} else if (!request.getURL().startsWith("http://")) {
return false;
}
/* Client wants Keep-Alive */
if (ProxyConfig.proxyKeepAlive) {
keepAlive = (request.containsHeaderField("Proxy-Connection")
&& request.getHeaderField("Proxy-Connection").equals("Keep-Alive"));
}
/* Filter the request. */
//deleted
/* None found. Use http or https relay. */
if (secure) {
http = createHttpsRelay(secureHost, securePort);
} else {
http = createHttpRelay();
}
try {
http.sendRequest(request);
if (http instanceof Http) {
((Http) http).setTimeout(ProxyConfig.readTimeout);
}
reply = http.recvReply(request);
} catch (RetryRequestException e) {
http.close();
http = null;
continue; /* XXX */
}
/* Guess content-type if there aren't any headers.
Probably an upgraded HTTP/0.9 reply. */
if (reply.headerCount() == 0) {
String url = request.getURL();
if (url.endsWith("/")
|| url.endsWith(".html") || url.endsWith(".htm")) {
reply.setHeaderField("Content-type", "text/html");
}
}
/* Filter the reply. */
if (false) {
/* uncompress gzip encoded html so it can be filtered */
if (!ProxyConfig.dontUncompress
&& "text/html".equals(reply.getHeaderField("Content-type"))) {
String encoding = reply.getHeaderField("Content-Encoding");
if (encoding != null && encoding.indexOf("gzip") != -1) {
reply.removeHeaderField("Content-Encoding");
reply.removeHeaderField("Content-length");
uncompress = true;
}
}
//filter(reply);
}
if (request.containsHeaderField("Connection") && (request.getHeaderField("Connection").toLowerCase().equals("keep-alive")) && reply.containsHeaderField("Connection")
&& reply.getHeaderField("Connection").equals("Keep-Alive")) {
keepAlive = true;
}
reply.removeHeaderField("Proxy-Connection");
if (keepAlive && reply.containsHeaderField("Content-length")) {
reply.setHeaderField("Proxy-Connection", "Keep-Alive");
} else {
keepAlive = false;
}
currentLength = -1;
contentLength = -1;
try {
contentLength = Integer.parseInt(reply.getHeaderField("Content-length"));
} catch (NumberFormatException e) {
}
if (http instanceof HttpsThrough) {
HttpsThrough https = (HttpsThrough) http;
int timeout = ProxyConfig.readTimeout;
client.write(reply);
try {
client.setTimeout(timeout);
https.setTimeout(timeout);
Copy cp = new Copy(client.getInputStream(), https.getOutputStream());
ReusableThread thread = Server.getThread();
thread.setRunnable(cp);
flushCopy(https.getInputStream(), client.getOutputStream(), -1, true);
client.close();
} catch (InterruptedIOException iioe) {
// ignore socket timeout exceptions
}
} else if (reply.hasContent()) {
try {
processContent(uncompress);
} catch (IOException e) {
if (http instanceof Http) {
((Http) http).reallyClose();
} else {
http.close();
}
http = null;
client.close();
client = null;
throw e;
//return false; /* XXX */
}
/* Document contains no data. */
if (contentLength == 0) {
client.close();
}
} else {
client.write(reply);
}
http.close();
}
return keepAlive;
}
HttpRelay createHttpsRelay(String secureHost, int securePort) throws IOException {
HttpRelay http;
if ((ProxyConfig.httpsMode == ProxyConfig.HTTPS_FILTER) || ((ProxyConfig.httpsMode == ProxyConfig.HTTPS_FILTERLIST) && (ProxyConfig.enabledHttpsServers.contains(secureHost)))) {
if (ProxyConfig.useHTTPSProxy) {
http = Https.open(ProxyConfig.httpsProxyHost, ProxyConfig.httpsProxyPort, true);
Request connectReq = new Request(null);
connectReq.setStatusLine("CONNECT " + secureHost + ":" + securePort + " HTTP/1.1");
connectReq.setCommand("CONNECT");
connectReq.setURL(secureHost + ":" + securePort);
connectReq.setProtocol("HTTP/1.1");
try {
http.sendRequest(connectReq);
Reply rep = http.recvReply(connectReq);
} catch (RetryRequestException ex) {
}
((Https) http).promoteToClientSSL();
} else {
http = Https.open(secureHost, securePort, false);
((Https) http).promoteToClientSSL();
}
/*http = new Http(request.getHost(),request.getPort(),ProxyConfig.useHTTPSProxy);
if(ProxyConfig.useHTTPSProxy){
Request connectReq=new Request(client);
connectReq.setCommand("CONNECT");
connectReq.setURL(secureHost+":"+securePort);
connectReq.setProtocol("HTTP/1.1");
try {
http.sendRequest(connectReq);
http.recvReply(connectReq);
} catch (RetryRequestException ex) {
}
}
((Http)http).promoteToClientSSL();*/
} else {
if (ProxyConfig.useHTTPSProxy) {
http = new HttpsThrough(ProxyConfig.httpsProxyHost,
ProxyConfig.httpsProxyPort,
true);
} else {
http = new HttpsThrough(secureHost, securePort);
}
}
return http;
}
HttpRelay createHttpRelay() throws IOException {
HttpRelay http;
if (ProxyConfig.useHTTPProxy) {
http = Http.open(ProxyConfig.httpProxyHost,
ProxyConfig.httpProxyPort,
true);
} else {
http = Http.open(request.getHost(), request.getPort());
}
return http;
}
InputStream readChunkedTransfer(InputStream in) throws IOException {
ByteArrayOutputStream chunks = new ByteArrayOutputStream(8192);
int size = 0;
contentLength = 0;
while ((size = reply.getChunkSize(in)) > 0) {
contentLength += size;
copy(in, chunks, size, true);
reply.readLine(in);
}
reply.getChunkedFooter(in);
reply.removeHeaderField("Transfer-Encoding");
reply.setHeaderField("Content-length", contentLength);
return new ByteArrayInputStream(chunks.toByteArray());
}
private static DateFormat httpDateFormat() {
DateFormat httpDateFormat = new SimpleDateFormat("EEE, dd MMM yyyy HH:mm:ss z", Locale.US);
httpDateFormat.setTimeZone(TimeZone.getTimeZone("GMT"));
return httpDateFormat;
}
void disableReplyCaching() {
reply.removeHeaderField("Cache-Control");
reply.removeHeaderField("Last-Modified");
reply.removeHeaderField("Expires");
reply.removeHeaderField("Date");
reply.removeHeaderField("ETag");
reply.removeHeaderField("Pragma");
reply.setHeaderField("Pragma", "no-cache");
reply.setHeaderField("Cache-Control", "no-cache, must-revalidate");
Calendar now = Calendar.getInstance();
reply.setHeaderField("Expires", httpDateFormat().format(now.getTime()));//"Sat, 26 Jul 1997 05:00:00 GMT");
reply.setHeaderField("Last-Modified", "Sat, 26 Jul 1997 05:00:00 GMT");
}
void processContent(boolean uncompress) throws IOException {
InputStream in;
boolean chunked = false;
if (reply.containsHeaderField("Transfer-Encoding")
&& reply.getTransferEncoding().equals("chunked")) {
in = readChunkedTransfer(reply.getContent());
chunked = true;
} else {
in = reply.getContent();
}
if (in == null) {
return;
} else if (uncompress) {
in = new GZIPInputStream(in);
}
String url = request.getURL();
boolean replaced = false;
for (Replacement r : replacements) {
if (r.matches(url)) {
r.lastAccess = Calendar.getInstance();
ByteArrayOutputStream buffer = new ByteArrayOutputStream();
try {
FileInputStream fis = new FileInputStream(r.targetFile);
byte[] buf = new byte[4096];
int pos = 0;
while ((pos = fis.read(buf)) > 0) {
buffer.write(buf, 0, pos);
}
fis.close();
buffer.close();
} catch (IOException ex) {
}
byte[] bytes = buffer.toByteArray();
contentLength = bytes.length;
reply.setHeaderField("Content-length", contentLength);
disableReplyCaching();
client.write(reply);
copy(new ByteArrayInputStream(bytes),
client.getOutputStream(), contentLength, false);
replaced = true;
if (replacedListener != null) {
replacedListener.replaced(r, request.getURL(), reply.getContentType());
}
break;
}
}
if (!replaced) {
String contentType = reply.getHeaderField("Content-type");
if (reply.getStatusCode() == 200) {
if (contentType != null) {
for (String ct : catchedContentTypes) {
String convContentType = contentType;
if (convContentType.contains(";")) {
convContentType = convContentType.substring(0, convContentType.indexOf(";"));
}
if (ct.toLowerCase().equals(convContentType.toLowerCase())) {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
copy(in, baos, contentLength, true);
byte[] data = baos.toByteArray();
if (catchedListener != null) {
byte[] newData = catchedListener.catched(ct, request.getURL(), new ByteArrayInputStream(data));
if (newData != null) {
data = newData;
contentLength = data.length;
reply.setHeaderField("Content-length", contentLength);
}
}
in = new ByteArrayInputStream(data);
disableReplyCaching();
break;
}
}
}
}
client.write(reply);
copy(in, client.getOutputStream(), contentLength, true);
}
}
/**
* Return the content length.
*/
int getTotalBytes() {
return contentLength > 0 ? contentLength : 0;
}
/**
* Return the number of bytes read so far.
*/
int getCurrentBytes() {
return currentLength > 0 ? currentLength : 0;
}
/**
* Send a error message to the client.
*
* @param out client
* @param e exception that occurred
* @param r request
*/
void error(OutputStream out, Exception e, Request r) {
StringBuffer buf = new StringBuffer();
buf.append("While trying to retrieve the URL: <a href=\"" + r.getURL() + "\">" + r.getURL() + "</a>\r\n");
buf.append("<p>\r\nThe following error was encountered:\r\n<p>\r\n");
buf.append("<ul><li>" + e.toString() + "</ul>\r\n");
String s = new HttpError(400, buf.toString()).toString();
try {
out.write(s.getBytes(), 0, s.length());
out.flush();
} catch (Exception ex) {
}
}
/**
* Copy in to out.
*
* @param in InputStream
* @param out OutputStream
* @param monitored Update the Monitor
*/
void copy(InputStream in, OutputStream out, int length, boolean monitored)
throws IOException {
if (length == 0) {
return;
}
int n;
byte[] buffer = new byte[8192];
long start = System.currentTimeMillis();
long now = 0, then = start;
bytesPerSecond = 0;
if (monitored) {
currentLength = 0;
}
for (;;) {
n = (length > 0) ? Math.min(length, buffer.length) : buffer.length;
n = in.read(buffer, 0, n);
if (n < 0) {
break;
}
out.write(buffer, 0, n);
if (monitored) {
currentLength += n;
}
now = System.currentTimeMillis();
bytesPerSecond = currentLength / ((now - start) / 1000.0);
// flush after 1 second
if (now - then > 1000) {
out.flush();
}
if (length != -1) {
length -= n;
if (length == 0) {
break;
}
}
then = now;
}
out.flush();
}
/**
* Copy in to out.
*
* @param in InputStream
* @param out OutputStream
* @param monitored Update the Monitor
*/
void flushCopy(InputStream in, OutputStream out, int length, boolean monitored)
throws IOException {
if (length == 0) {
return;
}
int n;
byte[] buffer = new byte[8192];
long start = System.currentTimeMillis();
bytesPerSecond = 0;
if (monitored) {
currentLength = 0;
}
for (;;) {
n = (length > 0) ? Math.min(length, buffer.length) : buffer.length;
n = in.read(buffer, 0, n);
if (n < 0) {
break;
}
out.write(buffer, 0, n);
out.flush();
if (monitored) {
currentLength += n;
}
bytesPerSecond = currentLength / ((System.currentTimeMillis() - start) / 1000.0);
if (length != -1) {
length -= n;
if (length == 0) {
break;
}
}
}
out.flush();
}
/**
* Return a string represenation of the hander's state.
*/
public String toString() {
StringBuffer str = new StringBuffer();
str.append("CLIENT ");
str.append(socket.getInetAddress().getHostAddress());
str.append(":");
str.append(socket.getPort());
str.append(" - ");
if (request == null) {
str.append("idle " + ((System.currentTimeMillis() - idle) / 1000.0) + " sec");
} else {
if (reply != null && currentLength > 0) {
str.append("(");
str.append(currentLength);
if (contentLength > 0) {
str.append("/");
str.append(contentLength);
}
str.append(" ");
str.append(((int) bytesPerSecond / 1024) + " kB/s");
str.append(") ");
}
str.append(request.getURL());
}
return str.toString();
}
}

284
libsrc/jpproxy/src/com/jpexs/proxy/Http.java
View File

@@ -1,284 +0,0 @@
package com.jpexs.proxy;
import java.io.IOException;
import java.net.Socket;
import java.util.Enumeration;
import java.util.Hashtable;
import java.util.Vector;
class Http extends HttpConnection {
/* XXX - more than 1 should work now. */
static final int MAX_PENDING_REQUESTS = 1;
static Hashtable cache = new Hashtable(33);
private static Object httpLock = new Object();
String host;
int port;
boolean proxy = false;
boolean persistent = false;
boolean closed = false;
long idle = 0;
Vector queue = new Vector();
public Http(String host, int port) throws IOException {
this(host, port, false);
}
public Http(String host, int port, boolean isProxy) throws IOException {
super(host, port);
this.host = host;
this.port = port;
this.proxy = isProxy;
}
public Http(String host, int port, boolean isProxy, Socket sock) throws IOException {
super(sock);
this.host = host;
this.port = port;
this.proxy = isProxy;
}
public synchronized void sendRequest(Request request)
throws IOException, RetryRequestException {
queue.addElement(request);
try {
send(request);
} catch (IOException e) {
if (persistent) {
persistent = false;
throw new RetryRequestException();
}
throw e;
}
}
public synchronized Reply recvReply(Request request)
throws IOException, RetryRequestException {
while (queue.firstElement() != request) {
try {
wait();
} catch (InterruptedException e) {
}
}
if (closed) {
throw new RetryRequestException();
}
try {
return recv();
} catch (IOException e) {
if (persistent) {
persistent = false;
throw new RetryRequestException();
}
throw e;
}
}
public void reallyClose() {
persistent = false;
close();
}
public synchronized void close() {
if (persistent) {
idle = System.currentTimeMillis();
} else {
cacheRemove(host, port, this);
super.close();
closed = true;
}
if (queue.size() > 0) {
queue.removeElementAt(0);
notify();
}
}
private void send(Request request) throws IOException {
/* Prepare HTTP/1.1 request */
request.removeHeaderField("Proxy-Connection");
if (!proxy) {
if (request.containsHeaderField("Connection") && (request.getHeaderField("Connection").toLowerCase().equals("keep-alive"))) {
} else {
request.setHeaderField("Connection", "open");
}
if (!request.containsHeaderField("Host")) {
request.setHeaderField("Host", request.getHost());
}
}
if (proxy) {
request.write(getOutputStream());
} else {
String oldStatusLine = request.statusLine;
StringBuffer head = new StringBuffer();
head.append(request.getCommand());
head.append(" ");
head.append(request.getPath());
head.append(" ");
head.append("HTTP/1.0");
request.statusLine = head.toString();
request.write(getOutputStream());
/* flush? */
request.statusLine = oldStatusLine;
}
}
private Reply recv() throws IOException {
Reply reply = new Reply(getInputStream());
reply.read();
String conn = reply.getHeaderField("Connection");
if (reply.containsHeaderField("Connection")
&& reply.getHeaderField("Connection").equals("close")) {
persistent = false;
} else if (reply.getProtocol().equals("HTTP/1.1")) {
persistent = true;
} else {
persistent = false;
}
/* Received HTTP/1.1 "Continue". Read another Reply. */
if (reply.getStatusCode() == 100) {
reply = recv();
}
return reply;
}
protected boolean isBusy() {
return queue.size() >= MAX_PENDING_REQUESTS;
}
protected boolean isPersistent() {
return persistent;
}
private static String cacheKey(String host, int port) {
return host.toLowerCase() + ":" + port;
}
private static Vector cacheLookup(String host, int port) {
Vector v = (Vector) cache.get(cacheKey(host, port));
return v;
}
private static boolean cacheContains(Http http) {
Vector v = (Vector) cache.get(cacheKey(http.host, http.port));
return v != null ? v.contains(http) : false;
}
private static void cacheInsert(String host, int port, Http http) {
String key = cacheKey(host, port);
Vector v = (Vector) cache.get(key);
if (v == null) {
v = new Vector();
}
v.addElement(http);
cache.put(key, v);
}
private static void cacheRemove(String host, int port, Http http) {
Vector v = (Vector) cache.get(cacheKey(host, port));
if (v != null) {
v.removeElement(http);
if (v.isEmpty()) {
cache.remove(cacheKey(host, port));
}
}
}
private static void cacheClean() {
long now = System.currentTimeMillis();
Enumeration e = cache.keys();
while (e.hasMoreElements()) {
Vector v = (Vector) cache.get(e.nextElement());
for (int i = 0; i < v.size(); i++) {
Http http = (Http) v.elementAt(i);
if (http.idle > 0 && now - http.idle > 30000) /* 30 seconds */ {
http.persistent = false;
http.close();
}
}
}
}
static Http open(String host, int port, boolean isProxy)
throws IOException {
Http http = null;
synchronized (httpLock) {
Vector v = cacheLookup(host, port);
if (v != null) {
for (int i = 0; i < v.size(); i++) {
Http pick = (Http) v.elementAt(i);
/* find an http connection that isn't busy */
if (pick.isPersistent() && !pick.isBusy()) {
http = pick;
break;
}
}
if (http != null) {
http.idle = 0;
}
}
}
if (http == null) {
http = new Http(host, port, isProxy);
cacheInsert(host, port, http);
}
return http;
}
static Http open(String host, int port) throws IOException {
return open(host, port, false);
}
static Enumeration enumerate() {
Vector list = new Vector();
Enumeration e = cache.keys();
while (e.hasMoreElements()) {
Vector v = (Vector) cache.get(e.nextElement());
for (int i = 0; i < v.size(); i++) {
list.addElement(v.elementAt(i));
}
}
return list.elements();
}
static synchronized void clean() {
cacheClean();
}
public String toString() {
StringBuffer buf = new StringBuffer();
buf.append("SERVER ");
buf.append(super.toString());
if (isPersistent()) {
buf.append(" - ");
if (queue.size() > 0) {
buf.append(queue.size());
buf.append(" pending");
} else {
buf.append("idle " + ((System.currentTimeMillis() - idle) / 1000.0) + " sec");
}
}
return buf.toString();
}
}

49
libsrc/jpproxy/src/com/jpexs/proxy/HttpConnection.java
View File

@@ -1,49 +0,0 @@
package com.jpexs.proxy;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.IOException;
import java.net.Socket;
abstract class HttpConnection extends Connection implements HttpRelay {
HttpConnection(String host, int port) throws IOException {
super(host, port);
}
HttpConnection(Socket s) throws IOException {
super(s);
}
public void sendRequest(Request request)
throws IOException, RetryRequestException {
request.write(getOutputStream());
}
public Reply recvReply(Request request)
throws IOException, RetryRequestException {
Reply reply = new Reply(getInputStream());
reply.read();
return reply;
}
public void setInputStream(InputStream in) {
super.setInputStream(in);
}
public void setOutputStream(OutputStream out) {
super.setOutputStream(out);
}
public InputStream getInputStream() {
return super.getInputStream();
}
public OutputStream getOutputStream() {
return super.getOutputStream();
}
public void close() {
super.close();
}
}

62
libsrc/jpproxy/src/com/jpexs/proxy/HttpError.java
View File

@@ -1,62 +0,0 @@
package com.jpexs.proxy;
class HttpError {
StringBuffer content = null;
Reply reply = null;
HttpError(int code, String message) {
String error;
switch (code) {
case 400:
error = "Bad Request";
break;
case 403:
error = "Forbidden";
break;
case 404:
error = "Not found";
break;
case 503:
error = "Service Unavailable";
break;
default:
error = "Error";
break;
}
reply = new Reply();
reply.statusLine = "HTTP/1.0 " + code + " " + error;
reply.setHeaderField("Content-type", "text/html");
reply.setHeaderField("Server", ProxyConfig.appName + "/" + ProxyConfig.appVersion);
content = new StringBuffer();
content.append(message);
}
Reply getReply() {
return reply;
}
String getContent() {
if (content == null) {
return null;
}
return content.toString();
}
public String toString() {
StringBuffer buf = new StringBuffer();
if (reply != null) {
buf.append(reply.toString());
}
if (content != null) {
buf.append(content.toString());
}
return buf.toString();
}
}

14
libsrc/jpproxy/src/com/jpexs/proxy/HttpRelay.java
View File

@@ -1,14 +0,0 @@
package com.jpexs.proxy;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.IOException;
public interface HttpRelay {
void sendRequest(Request request) throws IOException, RetryRequestException;
Reply recvReply(Request request) throws IOException, RetryRequestException;
void close();
}

127
libsrc/jpproxy/src/com/jpexs/proxy/Https.java
View File

@@ -1,127 +0,0 @@
package com.jpexs.proxy;
import java.io.IOException;
import java.util.Enumeration;
import java.util.Hashtable;
import java.util.Vector;
/**
*
* @author JPEXS
*/
public class Https extends Http {
/* XXX - more than 1 should work now. */
static final int MAX_PENDING_REQUESTS = 1;
static Hashtable cache = new Hashtable(33);
private static Object httpLock = new Object();
public Https(String host, int port) throws IOException {
this(host, port, false);
}
public Https(String host, int port, boolean isProxy) throws IOException {
super(host, port, isProxy);
}
private static String cacheKey(String host, int port) {
return host.toLowerCase() + ":" + port;
}
private static Vector cacheLookup(String host, int port) {
Vector v = (Vector) cache.get(cacheKey(host, port));
return v;
}
private static boolean cacheContains(Https http) {
Vector v = (Vector) cache.get(cacheKey(http.host, http.port));
return v != null ? v.contains(http) : false;
}
private static void cacheInsert(String host, int port, Https http) {
String key = cacheKey(host, port);
Vector v = (Vector) cache.get(key);
if (v == null) {
v = new Vector();
}
v.addElement(http);
cache.put(key, v);
}
private static void cacheRemove(String host, int port, Https http) {
Vector v = (Vector) cache.get(cacheKey(host, port));
if (v != null) {
v.removeElement(http);
if (v.isEmpty()) {
cache.remove(cacheKey(host, port));
}
}
}
private static void cacheClean() {
long now = System.currentTimeMillis();
Enumeration e = cache.keys();
while (e.hasMoreElements()) {
Vector v = (Vector) cache.get(e.nextElement());
for (int i = 0; i < v.size(); i++) {
Https http = (Https) v.elementAt(i);
if (http.idle > 0 && now - http.idle > 30000) /* 30 seconds */ {
http.persistent = false;
http.close();
}
}
}
}
static Https open(String host, int port, boolean isProxy)
throws IOException {
Https http = null;
synchronized (httpLock) {
Vector v = cacheLookup(host, port);
if (v != null) {
for (int i = 0; i < v.size(); i++) {
Https pick = (Https) v.elementAt(i);
/* find an http connection that isn't busy */
if (pick.isPersistent() && !pick.isBusy()) {
http = pick;
break;
}
}
if (http != null) {
http.idle = 0;
}
}
}
if (http == null) {
http = new Https(host, port, isProxy);
cacheInsert(host, port, http);
}
return http;
}
static Https open(String host, int port) throws IOException {
return open(host, port, false);
}
static Enumeration enumerate() {
Vector list = new Vector();
Enumeration e = cache.keys();
while (e.hasMoreElements()) {
Vector v = (Vector) cache.get(e.nextElement());
for (int i = 0; i < v.size(); i++) {
list.addElement(v.elementAt(i));
}
}
return list.elements();
}
static synchronized void clean() {
cacheClean();
}
}

39
libsrc/jpproxy/src/com/jpexs/proxy/HttpsThrough.java
View File

@@ -1,39 +0,0 @@
package com.jpexs.proxy;
import java.io.IOException;
class HttpsThrough extends HttpConnection {
boolean proxy = false;
HttpsThrough(String host, int port) throws IOException {
super(host, port);
}
HttpsThrough(String host, int port, boolean isProxy) throws IOException {
this(host, port);
proxy = isProxy;
}
public void sendRequest(Request request)
throws IOException, RetryRequestException {
if (proxy) {
super.sendRequest(request);
} else {
/* nothing */
}
}
public Reply recvReply(Request request)
throws java.io.IOException, RetryRequestException {
Reply reply = new Reply(getInputStream());
if (proxy) {
reply.read();
} else {
reply.statusLine = "HTTP/1.0 200 Connection established";
reply.setHeaderField("Proxy-agent", ProxyConfig.appName);
}
return reply;
}
}

34
libsrc/jpproxy/src/com/jpexs/proxy/Janitor.java
View File

@@ -1,34 +0,0 @@
package com.jpexs.proxy;
import java.util.Enumeration;
import java.util.Vector;
class Janitor implements Runnable {
private Vector cleanable = new Vector();
public void add(Cleanable c) {
cleanable.addElement(c);
}
public void run() {
Thread.currentThread().setName("Janitor");
for (;;) {
try {
Thread.sleep(30 * 1000); /* 30 seconds */
} catch (Exception e) {
}
for (Enumeration e = cleanable.elements();
e.hasMoreElements();) {
((Cleanable) e.nextElement()).clean();
}
Http.clean();
}
}
}

35
libsrc/jpproxy/src/com/jpexs/proxy/Key.java
View File

@@ -1,35 +0,0 @@
package com.jpexs.proxy;
class Key {
private String name = null;
/**
* Create a Key.
*/
Key(String name) {
this.name = name;
}
/**
* Return a lowercase hashCode.
*/
public int hashCode() {
String s = name.toLowerCase();
return s.hashCode();
}
/**
* Return a lowercase equals.
*/
public boolean equals(Object obj) {
return name.equalsIgnoreCase(obj.toString());
}
/**
* Return the key.
*/
public String toString() {
return name;
}
}

65
libsrc/jpproxy/src/com/jpexs/proxy/Main.java
View File

@@ -1,65 +0,0 @@
package com.jpexs.proxy;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.List;
public class Main {
public static final String REPLACEMENTSFILE = "." + File.separator + "config" + File.separator + "replacements.ini";
public static boolean DEBUG_MODE = false;
public static void main(String[] argv) {
List<Replacement> replacements = new ArrayList<Replacement>();
if ((new File(REPLACEMENTSFILE)).exists()) {
try {
BufferedReader br = new BufferedReader(new FileReader(REPLACEMENTSFILE));
String s = "";
while ((s = br.readLine()) != null) {
String fileName = br.readLine();
if (fileName == null) {
break;
}
fileName = fileName.replaceAll("[\\\\/]", File.separator);
Replacement r = new Replacement(s, fileName);
if (DEBUG_MODE) {
System.out.println("Added Replacement: " + r.urlPattern + " => " + r.targetFile);
}
replacements.add(r);
}
br.close();
} catch (IOException e) {
}
} else {
if (DEBUG_MODE) {
System.out.println("WARNING:REPLACEMENTS FILE NOT FOUND.");
}
}
Server.startServer(ProxyConfig.port, replacements, new ArrayList<String>(), new CatchedListener() {
/**
* Method called when specified contentType is received
*
* @param contentType Content type
* @param url URL of the method
* @param data Data stream
*/
public byte[] catched(String contentType, String url, InputStream data) {
return null;
}
}, new ReplacedListener() {
public void replaced(Replacement replacement, String url, String contentType) {
if (DEBUG_MODE) {
System.out.println("REPLACED:" + url + " (Content-type:" + contentType + ") WITH FILE " + replacement.targetFile);
}
}
});
}
}

242
libsrc/jpproxy/src/com/jpexs/proxy/Message.java
View File

@@ -1,242 +0,0 @@
package com.jpexs.proxy;
import java.util.Hashtable;
import java.util.Enumeration;
import java.util.Vector;
import java.io.*;
public abstract class Message {
/**
* Hashtable used to store message headers.
*/
private Hashtable headers = new Hashtable(33);
/**
*
*/
String statusLine = null;
public String readLine(InputStream in) throws IOException {
char[] buf = new char[128];
int offset = 0;
int ch;
for (;;) {
ch = in.read();
if (ch == -1 || ch == '\n') {
break;
} else if (ch == '\r') {
int tmpch = in.read();
if (tmpch != '\n') {
if (!(in instanceof PushbackInputStream)) {
in = new PushbackInputStream(in);
}
((PushbackInputStream) in).unread(tmpch);
}
break;
} else {
if (offset == buf.length) {
char[] tmpbuf = buf;
buf = new char[tmpbuf.length * 2];
System.arraycopy(tmpbuf, 0, buf, 0, offset);
}
buf[offset++] = (char) ch;
}
}
return String.copyValueOf(buf, 0, offset);
}
/**
* Read headers and store them in the hashtable.
*/
void readHeaders(InputStream in) throws IOException {
int i;
Key key = null;
for (;;) {
String s = readLine(in);
if (s == null) {
break;
}
i = s.indexOf(':');
if (i == -1) {
/* end of header */
if (s.length() == 0) {
break;
} /* multi-line headers */ else if (key != null
&& (s.startsWith(" ") || s.startsWith("\t"))) {
int index = getHeaderValueCount(key.toString());
index--;
Vector v = (Vector) headers.get(key);
v.setElementAt(v.elementAt(index) + "\n" + s, index);
}
} else {
key = new Key(s.substring(0, i));
Vector v;
if (headers.containsKey(key)) {
v = (Vector) headers.get(key);
} else {
v = new Vector();
}
v.addElement(s.substring(i + 1).trim());
headers.put(key, v);
}
}
}
public int headerCount() {
return headers.size();
}
/**
* Set the Status line.
*/
public void setStatusLine(String l) {
statusLine = l;
}
public int getHeaderValueCount(String name) {
Vector v = (Vector) headers.get(new Key(name));
return v.size();
}
public String getHeaderField(String name) {
return getHeaderField(name, 0);
}
public String getHeaderField(String name, int index) {
Vector v = (Vector) headers.get(new Key(name));
if (v == null) {
return null;
}
return (String) v.elementAt(index);
}
public void setHeaderField(String name, String value) {
setHeaderField(name, value, 0);
}
public void setHeaderField(String name, String value, int index) {
Vector v;
Key key = new Key(name);
if (headers.containsKey(key)) {
v = (Vector) headers.get(key);
} else {
v = new Vector();
if (index == 0) {
v.addElement("");
}
headers.put(key, v);
}
v.setElementAt(value, index);
}
public void setHeaderField(String name, int value) {
setHeaderField(name, value, 0);
}
public void setHeaderField(String name, int value, int index) {
setHeaderField(name, new Integer(value).toString(), index);
}
/**
* Set all header fields with the give name to the specified value.
*/
public void setHeaderFields(String name, String value) {
Vector v;
Key key = new Key(name);
v = (Vector) headers.get(key);
if (v != null) {
for (int i = 0; i < v.size(); i++) {
v.setElementAt(value, i);
}
}
}
public void appendHeaderField(String name, String value) {
appendHeaderField(name, value, 0);
}
public void appendHeaderField(String name, String value, int index) {
setHeaderField(name, getHeaderField(name, index) + value, index);
}
public void removeHeaderField(String name) {
headers.remove(new Key(name));
}
/**
* Return whether or not a header exists.
*
* @param name header name
*/
public boolean containsHeaderField(String name) {
return headers.containsKey(new Key(name));
}
/**
* @return an Enumeration of Strings
*/
public Enumeration getHeaders() {
Vector v = new Vector();
for (Enumeration e = headers.keys(); e.hasMoreElements();) {
v.addElement(e.nextElement().toString());
}
return v.elements();
}
private final static byte[] COLON_SPACE = ": ".getBytes();
private final static byte[] CRLF = "\r\n".getBytes();
private ByteArray toByteArray(byte[] sep) {
ByteArray buf = new ByteArray();
Key key;
String value;
Vector v;
int i = 0;
buf.append(statusLine);
buf.append(sep);
for (Enumeration e = headers.keys(); e.hasMoreElements();) {
key = (Key) e.nextElement();
v = (Vector) headers.get(key);
for (i = 0; i < v.size(); i++) {
buf.append(key.toString());
buf.append(COLON_SPACE);
buf.append(v.elementAt(i).toString());
buf.append(sep);
}
}
buf.append(sep);
return buf;
}
private ByteArray toByteArray() {
return toByteArray(CRLF);
}
private ByteArray toByteArray(String sep) {
return toByteArray(sep.getBytes());
}
public String toString() {
return toByteArray().toString();
}
public String toString(String sep) {
return toByteArray(sep).toString();
}
public void write(OutputStream out)
throws IOException {
toByteArray().writeTo(out);
out.flush();
}
}

43
libsrc/jpproxy/src/com/jpexs/proxy/ProxyConfig.java
View File

@@ -1,43 +0,0 @@
package com.jpexs.proxy;
import java.util.ArrayList;
import java.util.List;
/**
*
* @author JPEXS
*/
public class ProxyConfig {
public static boolean dontLogFilters = false;
public static String appVersion = "1.1";
public static String appName = "JPProxy";
public static int port = 55555;
public static String bindAddress;
public static int readTimeout = 50000;
public static boolean proxyKeepAlive = false;
public static boolean dontUncompress = false;
public static final int HTTPS_PASSTHRU = 0;
public static final int HTTPS_FILTER = 1;
public static final int HTTPS_FILTERLIST = 2;
public static int httpsMode = HTTPS_PASSTHRU;
public static List<String> enabledHttpsServers = new ArrayList<String>();
public static boolean useHTTPSProxy = false;
public static String httpsProxyHost = "";
public static int httpsProxyPort = 0;
public static boolean useHTTPProxy = false;
public static String httpProxyHost = "";
public static int httpProxyPort = 0;
public static String httpsKeyStoreFile = null;
public static String httpsKeyStorePass = null;
public static String httpsKeyPass = null;
}

6
libsrc/jpproxy/src/com/jpexs/proxy/ReplacedListener.java
View File

@@ -1,6 +0,0 @@
package com.jpexs.proxy;
public interface ReplacedListener {
public void replaced(Replacement replacement, String url, String contentType);
}

80
libsrc/jpproxy/src/com/jpexs/proxy/Replacement.java
View File

@@ -1,80 +0,0 @@
package com.jpexs.proxy;
import java.io.File;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.regex.Pattern;
/**
* Replacement of URL with local file
*/
public class Replacement {
/**
* URL pattern, can contain * wild-cards
*/
public String urlPattern;
/**
* Filename to replace content with
*/
public String targetFile;
/**
* Date of last accesing this url
*/
public Calendar lastAccess;
/**
* Constructor
*
* @param urlPattern URL pattern, can contain * wild-cards
* @param targetFile Filename to replace content with
*/
public Replacement(String urlPattern, String targetFile) {
this.urlPattern = urlPattern;
this.targetFile = targetFile;
}
/**
* Returns true when urlPattern matches specified url
*
* @param url Url to test match
* @return True when matches
*/
public boolean matches(String url) {
String pat = Pattern.quote(urlPattern);
pat = pat.replace("*", "\\E.*\\Q");
return Pattern.matches(pat, url);
}
private static String byteCountStr(long bytes, boolean si) {
int unit = si ? 1000 : 1024;
if (bytes < unit) {
return bytes + " B";
}
int exp = (int) (Math.log(bytes) / Math.log(unit));
String pre = (si ? "kMGTPE" : "KMGTPE").charAt(exp - 1) + (si ? "" : "i");
return String.format("%.1f %sB", bytes / Math.pow(unit, exp), pre);
}
/**
* Returns a string representation of the object.
*
* @return a string representation of the object.
*/
@Override
public String toString() {
SimpleDateFormat format = new SimpleDateFormat("HH:mm:ss");
long size = new File(targetFile).length();
String sizeS = byteCountStr(size, false);
while (sizeS.length() < 12) {
sizeS = " " + sizeS;
}
if (lastAccess == null) {
return " " + " | " + sizeS + " | " + urlPattern;
} else {
return format.format(lastAccess.getTime()) + " | " + sizeS + " | " + urlPattern;
}
}
}

202
libsrc/jpproxy/src/com/jpexs/proxy/Reply.java
View File

@@ -1,202 +0,0 @@
package com.jpexs.proxy;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.IOException;
import java.io.StringBufferInputStream;
import java.io.SequenceInputStream;
import java.util.Hashtable;
import java.util.StringTokenizer;
public class Reply extends Message {
InputStream in = null;
int statusCode = -1;
public Reply() {
}
public Reply(InputStream in) {
setContent(in);
}
public void setContent(InputStream in) {
this.in = in;
}
public InputStream getContent() {
return in;
}
void read() throws IOException {
if (in != null) {
read(in);
}
}
void read(InputStream in) throws IOException {
statusLine = readLine(in);
if (statusLine == null || statusLine.length() == 0) {
throw new IOException("Missing HTTP status line");
}
/* Look for HTTP/0.9 */
if (!statusLine.startsWith("HTTP")) {
/* Put back the line */
if (this.in != null) {
String putback = new String(statusLine + "\n");
this.in = new SequenceInputStream(new StringBufferInputStream(putback), in);
}
/* Fake a status line and upgrade to HTTP/1.0 */
statusLine = "HTTP/1.0 200 OK";
return;
}
readHeaders(in);
int code = getStatusCode();
/* RFC 2068: 204 and 304 MUST NOT contain a message body. */
switch (code) {
case 204: /* No Content */
case 304: /* Not Modified */
/* Ignore the message body if it exists */
if (containsHeaderField("Content-length")) {
int contentLength = 0;
try {
contentLength = Integer.parseInt(getHeaderField("Content-length"));
} catch (NumberFormatException e) {
}
int n;
byte[] buffer = new byte[8192];
while ((n = in.read(buffer, 0, buffer.length)) > 0) {
/* ignore */
}
removeHeaderField("Content-length");
}
break;
}
}
public boolean hasContent() {
switch (getStatusCode()) {
case 204:
case 304:
return false;
default:
return true;
}
}
public String getProtocol() {
StringTokenizer st = new StringTokenizer(statusLine);
String protocol = (String) st.nextToken();
return protocol;
}
public int getStatusCode() {
if (statusCode == -1) {
StringTokenizer st = new StringTokenizer(statusLine);
String protocol = (String) st.nextToken();
String status = (String) st.nextToken();
try {
statusCode = Integer.parseInt(status);
} catch (NumberFormatException e) {
System.out.println("Malformed or missing status code");
statusCode = 0;
}
}
return statusCode;
}
private Hashtable headerParser(String header) {
Hashtable table = new Hashtable();
String type = getHeaderField(header);
if (type == null) {
return table;
}
StringTokenizer st = new StringTokenizer(type, ";");
int count = 0;
while (st.hasMoreTokens()) {
String token = st.nextToken();
token = token.trim();
String name;
String value;
int i = token.indexOf('=');
if (i != -1) {
name = token.substring(0, i);
value = token.substring(i + 1);
} else {
name = token;
value = "";
}
if (count == 0) {
table.put(header, name);
} else {
table.put(name, value);
}
count++;
}
return table;
}
public String getContentType() {
Hashtable table = headerParser("Content-type");
return (String) table.get("Content-type");
}
public String getBoundary() {
Hashtable table = headerParser("Content-type");
return (String) table.get("boundary");
}
public String getTransferEncoding() {
Hashtable table = headerParser("Transfer-Encoding");
return (String) table.get("Transfer-Encoding");
}
public int getChunkSize(InputStream in) throws IOException {
String line = readLine(in);
line = line.trim(); /* apache can have trailing spaces */
int size = -1;
try {
size = Integer.valueOf(line, 16).intValue();
} catch (NumberFormatException e) {
System.out.println(e);
}
return size;
}
public void getChunkedFooter(InputStream in) throws IOException {
for (;;) {
String line = readLine(in);
if (line == null) {
break;
}
int i = line.indexOf(':');
if (i == -1) {
break;
}
}
}
public void setStatusLine(String line) {
this.statusLine = line;
}
public static Reply createRedirect(String url) {
Reply r = new Reply();
r.setStatusLine("HTTP/1.0 302 Moved Temporarily");
r.setHeaderField("Location", url);
return r;
}
}

223
libsrc/jpproxy/src/com/jpexs/proxy/Request.java
View File

@@ -1,223 +0,0 @@
package com.jpexs.proxy;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.IOException;
import java.util.StringTokenizer;
import java.util.Enumeration;
import java.util.Hashtable;
import java.util.Vector;
public class Request extends Message {
private String command = null;
private String url = null;
private String protocol = null;
private byte[] data = null;
private Client client = null;
private Hashtable log;
private Vector logHeaders;
public boolean hadKeepalive = false;
Request(Client c) {
client = c;
}
void read(InputStream in) throws IOException {
statusLine = readLine(in);
if (statusLine == null || statusLine.length() == 0) {
throw new IOException("Empty request");
}
StringTokenizer st = new StringTokenizer(statusLine);
command = (String) st.nextToken();
url = (String) st.nextToken();
protocol = (String) st.nextToken();
if (!url.startsWith("http")) {
//TODO do something here
}
readHeaders(in);
if ("POST".equals(command) || "PUT".equals(command)) {
try {
int n = Integer.parseInt(getHeaderField("Content-length"));
data = new byte[n];
int offset = 0;
while (offset < data.length) {
n = in.read(data, offset, data.length - offset);
if (n < 0) {
throw new IOException("Not enough " + command + " data");
}
offset += n;
}
} catch (NumberFormatException e) {
}
}
}
public void write(OutputStream out)
throws IOException {
super.write(out);
if (data != null) {
out.write(data);
out.flush();
}
}
public String getRequest() {
return statusLine;
}
public String getCommand() {
return command;
}
public void setCommand(String command) {
this.command = command;
}
public String getURL() {
return url;
}
public void setURL(String url) {
this.url = url;
}
public String getProtocol() {
return protocol;
}
public void setProtocol(String protocol) {
this.protocol = protocol;
}
public void addSecureHostToURL(String host) {
url = "https://" + host + url;
}
public String getHost() {
String url = getURL();
String s;
if (url.startsWith("http://")) {
s = url.substring(7, url.indexOf('/', 7));
} else if (url.startsWith("https://")) {
s = url.substring(8, url.indexOf('/', 8));
} else {
s = url;
}
int at = s.indexOf('@');
if (at != -1) {
s = s.substring(at + 1);
}
if (s.indexOf(':') != -1) {
return s.substring(0, s.indexOf(':'));
}
return s;
}
public int getPort() {
int port = 80;
String url = getURL();
String s;
if (url.startsWith("http://")) {
s = url.substring(7, url.indexOf('/', 7));
} else if (url.startsWith("https://")) {
s = url.substring(8, url.indexOf('/', 8));
port = 443;
} else {
s = url;
}
int at = s.indexOf('@');
if (at != -1) {
s = s.substring(at + 1);
}
if (s.indexOf(':') != -1) {
try {
port = Integer.parseInt(s.substring(s.indexOf(':') + 1));
} catch (NumberFormatException e) {
}
}
return port;
}
public String getData() {
if (data == null) {
return null;
}
return new String(data);
}
public String getPath() {
String str = getURL();
int pos = 0;
for (int i = 0; i < 3; i++) {
pos = str.indexOf('/', pos);
pos++;
}
pos--;
return str.substring(pos);
}
public String getDocument() {
String path = getPath();
int n = path.lastIndexOf('/');
if (n == path.length() - 1) {
n = path.lastIndexOf('/', n - 1);
}
if (n < 0) {
return "/";
} else {
return path.substring(n + 1);
}
}
public Client getClient() {
return client;
}
public String getQueryString() {
String path = getPath();
int n = path.indexOf('?');
if (n < 0) {
return null;
}
return path.substring(n + 1);
}
public synchronized void addLogEntry(String header,
String message) {
if (log == null) {
log = new Hashtable();
logHeaders = new Vector();
}
Vector v = (Vector) log.get(header);
if (log.get(header) == null) {
v = new Vector();
log.put(header, v);
logHeaders.addElement(header);
}
v.addElement(message);
}
public Enumeration getLogHeaders() {
return logHeaders != null ? logHeaders.elements() : null;
}
public Enumeration getLogEntries(String header) {
return log != null ? ((Vector) log.get(header)).elements() : null;
}
}

12
libsrc/jpproxy/src/com/jpexs/proxy/RetryRequestException.java
View File

@@ -1,12 +0,0 @@
package com.jpexs.proxy;
class RetryRequestException extends Exception {
RetryRequestException() {
super();
}
RetryRequestException(String message) {
super(message);
}
}

57
libsrc/jpproxy/src/com/jpexs/proxy/ReusableThread.java
View File

@@ -1,57 +0,0 @@
package com.jpexs.proxy;
public class ReusableThread extends Thread {
private ThreadPool pool = null;
private Runnable runnable = null;
private boolean alive = true;
private long lastrun = 0;
private int used = 0;
public ReusableThread(ThreadPool pool) {
this.pool = pool;
}
public synchronized void setRunnable(Runnable runnable) {
this.runnable = runnable;
notify();
}
public synchronized void terminate() {
alive = false;
notify();
}
public long getLastRunTime() {
return lastrun;
}
public int useCount() {
return used;
}
public void run() {
while (alive) {
setName("ReusableThread: idle");
while (runnable == null && alive) {
synchronized (this) {
try {
wait();
} catch (InterruptedException ie) {
}
}
}
if (alive) {
setName("ReusableThread: busy");
setPriority(Thread.NORM_PRIORITY);
lastrun = System.currentTimeMillis();
used++;
runnable.run();
runnable = null;
pool.put(this);
}
}
}
}

139
libsrc/jpproxy/src/com/jpexs/proxy/Server.java
View File

@@ -1,139 +0,0 @@
package com.jpexs.proxy;
import java.net.InetAddress;
import java.net.Socket;
import java.net.ServerSocket;
import java.io.IOException;
import java.io.DataOutputStream;
import java.util.List;
public class Server implements Runnable {
ServerSocket server = null;
boolean running = false;
private List<String> catchedContentTypes;
private CatchedListener catchedListener;
private ReplacedListener replacedListener;
private List<Replacement> replacements;
static ThreadPool pool;
static Server myServer;
static boolean serverRunning = false;
static boolean stopping = false;
public static ReusableThread getThread() {
return pool.get();
}
/**
* Starts proxy server
*
* @param port Listening port
* @param replacements List of replacements
* @param catchedContentTypes Content types to sniff
* @param catchedListener Catched listener
*/
public static boolean startServer(int port, List<Replacement> replacements, List<String> catchedContentTypes, CatchedListener catchedListener, ReplacedListener replacedListener) {
stopServer();
stopping = false;
try {
myServer = new Server(port, replacements, catchedContentTypes, catchedListener, replacedListener);
} catch (IOException ex) {
return false;
}
pool = new ThreadPool(ProxyConfig.appName + " Threads");
/* Startup the Janitor */
Janitor j = new Janitor();
j.add(pool);
getThread().setRunnable(j);
serverRunning = true;
getThread().setRunnable(myServer);
return true;
}
public static void stopServer() {
if (serverRunning) {
stopping = true;
serverRunning = false;
try {
myServer.server.close();
} catch (IOException ex) {
}
pool.clean();
}
}
Server(int port, List<Replacement> replacements, List<String> catchedContentTypes, CatchedListener catchedListener, ReplacedListener replacedListener) throws IOException {
this.replacements = replacements;
this.catchedContentTypes = catchedContentTypes;
this.catchedListener = catchedListener;
this.replacedListener = replacedListener;
try {
String bindaddr = ProxyConfig.bindAddress;
if (bindaddr != null && bindaddr.length() > 0) {
server = new ServerSocket(port, 512,
InetAddress.getByName(bindaddr));
} else {
server = new ServerSocket(port, 512);
}
} catch (IOException e) {
throw e;
}
/* Initialize internal Httpd */
}
synchronized void suspend() {
running = false;
}
synchronized void resume() {
running = true;
}
public void run() {
Thread.currentThread().setName(ProxyConfig.appName + " Server");
running = true;
for (;;) {
Socket socket;
try {
socket = server.accept();
} catch (IOException e) {
if (stopping) {
break;
}
continue;
}
if (stopping) {
break;
}
if (running) {
Handler h = new Handler(socket, replacements, catchedContentTypes, catchedListener, replacedListener);
ReusableThread rt = getThread();
rt.setRunnable(h);
} else {
error(socket, 503, ProxyConfig.appName + " proxy service is suspended.");
}
}
}
void error(Socket socket, int code, String message) {
try {
DataOutputStream out = new DataOutputStream(socket.getOutputStream());
out.writeBytes((new HttpError(code, message)).toString());
out.close();
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}

45
libsrc/jpproxy/src/com/jpexs/proxy/ThreadPool.java
View File

@@ -1,45 +0,0 @@
package com.jpexs.proxy;
import java.util.*;
public class ThreadPool implements Cleanable {
private String name;
private Vector pool = new Vector();
public ThreadPool(String name) {
this.name = name;
}
public synchronized ReusableThread get() {
ReusableThread rt = null;
if (pool.size() > 0) {
rt = (ReusableThread) pool.firstElement();
pool.removeElement(rt);
}
if (rt == null) {
rt = new ReusableThread(this);
rt.start();
}
return rt;
}
public synchronized void put(ReusableThread rt) {
pool.addElement(rt);
}
public synchronized void clean() {
long now = System.currentTimeMillis();
for (Enumeration e = pool.elements(); e.hasMoreElements();) {
ReusableThread rt = (ReusableThread) e.nextElement();
if (now - rt.getLastRunTime() >= 30000) {
rt.terminate();
pool.removeElement(rt);
}
}
}
}

134
libsrc/jpproxy/src/com/jpexs/proxy/WorkerThread.java
View File

@@ -1,134 +0,0 @@
package com.jpexs.proxy;
import java.util.*;
public class WorkerThread extends Thread {
private Runnable task;
private String name;
private static int nactive = 0;
private static Vector list = new Vector();
private static int max = 10;
private static long lifetime = 900 * 1000; /* 15 minute default */
private
WorkerThread() {
setDaemon(true);
}
/**
* Sets the lifetime of an idle WorkerThread (in ms). A WorkerThread will
* remain on the idle list for this much time before exiting. This does not
* affect WorkerThreads currently idling.
*/
synchronized static void
setLifetime(long time) {
lifetime = time;
}
/**
* Sets the maximum number of WorkerThreads that can exist at any given
* time. If this value is decreased below the current number of
* WorkerThreads, this will not take effect immediately.
*/
synchronized static void
setMaxThreads(int maxThreads) {
max = maxThreads;
}
/**
* Obtains a WorkerThread to which a task can be assigned. If an idle
* WorkerThread is present, it is removed from the idle list and returned.
* If not, and the maximum number of WorkerThreads has not been reached, a
* new WorkerThread is created. If the maximum number has been reached, this
* blocks until a WorkerThread is free.
*/
static WorkerThread
getThread() {
WorkerThread t;
synchronized (list) {
if (list.size() > 0) {
t = (WorkerThread) list.firstElement();
list.removeElement(t);
} else if (nactive >= max) {
while (true) {
try {
list.wait();
} catch (InterruptedException e) {
}
if (list.size() == 0) {
continue;
}
t = (WorkerThread) list.firstElement();
list.removeElement(t);
break;
}
} else {
t = new WorkerThread();
}
nactive++;
}
return t;
}
/**
* Assigns a task to a WorkerThread
*
* @param task The task to be run
* @param name The name of the task
*/
public static void
assignThread(Runnable task, String name) {
while (true) {
try {
WorkerThread t = getThread();
synchronized (t) {
t.task = task;
t.name = name;
if (!t.isAlive()) {
t.start();
} else {
t.notify();
}
}
return;
} catch (IllegalThreadStateException e) {
}
}
}
/**
* Performs the task
*/
synchronized public void
run() {
while (true) {
setName(name);
try {
task.run();
} catch (Throwable t) {
System.err.println(t);
}
setName("idle thread");
synchronized (list) {
list.addElement(this);
if (nactive >= max) {
list.notify();
}
nactive--;
}
task = null;
try {
wait(lifetime);
} catch (InterruptedException e) {
}
if (task == null) {
list.removeElement(this);
return;
}
}
}
}