import java.io.OutputStreamWriter;
import java.net.Socket;
+import javax.net.ssl.SSLException;
+
+import be.nikiroo.utils.CryptUtils;
import be.nikiroo.utils.Version;
import be.nikiroo.utils.serial.Exporter;
import be.nikiroo.utils.serial.Importer;
private Version version;
private Version clientVersion;
+ private CryptUtils crypt;
+
private Object lock = new Object();
private BufferedReader in;
private OutputStreamWriter out;
private boolean contentToSend;
+ private long bytesReceived;
+ private long bytesSent;
+
/**
* Method that will be called when an action is performed on either the
* client or server this {@link ConnectAction} represent.
* Handler called when an unexpected error occurs in the code.
*
* @param e
- * the exception that occurred
+ * the exception that occurred, SSLException usually denotes a
+ * crypt error
*/
abstract protected void onError(Exception e);
* @param server
* TRUE for a server action, FALSE for a client action (will
* impact the process)
+ * @param key
+ * an optional key to encrypt all the communications (if NULL,
+ * everything will be sent in clear text)
* @param version
* the version of this client-or-server
*/
- protected ConnectAction(Socket s, boolean server, Version version) {
+ protected ConnectAction(Socket s, boolean server, String key,
+ Version version) {
this.s = s;
this.server = server;
+ if (key != null) {
+ crypt = new CryptUtils(key);
+ }
if (version == null) {
this.version = new Version();
return version;
}
+ /**
+ * The total amount of bytes received.
+ *
+ * @return the amount of bytes received
+ */
+ public long getBytesReceived() {
+ return bytesReceived;
+ }
+
+ /**
+ * The total amount of bytes sent.
+ *
+ * @return the amount of bytes sent
+ */
+ public long getBytesSent() {
+ return bytesSent;
+ }
+
/**
* Actually start the process (this is synchronous).
*/
out = new OutputStreamWriter(s.getOutputStream(), "UTF-8");
try {
if (server) {
- String line = in.readLine();
+ String line;
+ try {
+ line = readLine(in);
+ } catch (SSLException e) {
+ out.write("Unauthorized\n");
+ throw e;
+ }
+
if (line != null && line.startsWith("VERSION ")) {
// "VERSION client-version" (VERSION 1.0.0)
Version clientVersion = new Version(
}
} finally {
out.close();
+ out = null;
}
} finally {
in.close();
+ in = null;
}
} catch (Exception e) {
onError(e);
protected Object sendObject(Object data) throws IOException,
NoSuchFieldException, NoSuchMethodException, ClassNotFoundException {
synchronized (lock) {
- String rep = sendString(new Exporter().append(data).toString(true));
+ String rep = sendString(new Exporter().append(data).toString(true,
+ true));
if (rep != null) {
return new Importer().read(rep).getValue();
}
*
* @throws IOException
* in case of I/O error
+ * @throws SSLException
+ * in case of crypt error
*/
protected String sendString(String line) throws IOException {
synchronized (lock) {
- out.write(line);
- out.write("\n");
+ writeLine(out, line);
if (server) {
out.flush();
*
* @throws IOException
* in case of I/O error
+ * @throws SSLException
+ * in case of crypt error
*/
protected String recString() throws IOException {
synchronized (lock) {
contentToSend = false;
}
- return in.readLine();
+ return readLine(in);
}
return null;
}
}
+
+ /**
+ * Read a possibly encrypted line.
+ *
+ * @param in
+ * the stream to read from
+ * @return the unencrypted line
+ *
+ *
+ * @throws IOException
+ * in case of I/O error
+ * @throws SSLException
+ * in case of crypt error
+ */
+ private String readLine(BufferedReader in) throws IOException {
+ String line = in.readLine();
+ if (line != null) {
+ bytesReceived += line.length();
+ if (crypt != null) {
+ line = crypt.decrypt64s(line, false);
+ }
+ }
+
+ return line;
+ }
+
+ /**
+ * Write a line, possible encrypted.
+ *
+ * @param out
+ * the stream to write to
+ * @param line
+ * the line to write
+ * @throws IOException
+ * in case of I/O error
+ * @throws SSLException
+ * in case of crypt error
+ */
+ private void writeLine(OutputStreamWriter out, String line)
+ throws IOException {
+ if (crypt == null) {
+ out.write(line);
+ bytesSent += line.length();
+ } else {
+ // TODO: how NOT to create so many big Strings?
+ String b64 = crypt.encrypt64(line, false);
+ out.write(b64);
+ bytesSent += b64.length();
+ }
+ out.write("\n");
+ bytesSent++;
+ }
}
\ No newline at end of file