/* This code is part of Freenet. It is distributed under the GNU General
* Public License, version 2 (or at your option any later version). See
* http://www.gnu.org/ for further details of the GPL. */
package freenet.node;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.net.SocketException;
import java.util.Arrays;
import freenet.client.HighLevelSimpleClient;
import freenet.config.Config;
import freenet.config.InvalidConfigValueException;
import freenet.config.SubConfig;
import freenet.crypt.RandomSource;
import freenet.crypt.SSL;
import freenet.io.NetworkInterface;
import freenet.io.SSLNetworkInterface;
import freenet.support.Logger;
import freenet.support.api.BooleanCallback;
import freenet.support.api.IntCallback;
import freenet.support.api.StringCallback;
public class TextModeClientInterfaceServer implements Runnable {
final RandomSource r;
final Node n;
final NodeClientCore core;
final File downloadsDir;
int port;
String bindTo;
String allowedHosts;
boolean isEnabled;
private static boolean ssl = false;
final NetworkInterface networkInterface;
TextModeClientInterfaceServer(Node node, NodeClientCore core, int port, String bindTo, String allowedHosts) throws IOException {
this.n = node;
this.core = n.clientCore;
this.r = n.random;
this.downloadsDir = core.getDownloadsDir();
this.port=port;
this.bindTo=bindTo;
this.allowedHosts = allowedHosts;
this.isEnabled=true;
if(ssl) {
networkInterface = SSLNetworkInterface.create(port, bindTo, allowedHosts, n.executor, true);
} else {
networkInterface = NetworkInterface.create(port, bindTo, allowedHosts, n.executor, true);
}
}
void start() {
Logger.normal(core, "TMCI started on "+networkInterface.getAllowedHosts()+ ':' +port);
System.out.println("TMCI started on "+networkInterface.getAllowedHosts()+ ':' +port);
n.executor.execute(this, "Text mode client interface");
}
public static TextModeClientInterfaceServer maybeCreate(Node node, NodeClientCore core, Config config) throws IOException {
TextModeClientInterfaceServer server = null;
SubConfig TMCIConfig = config.createSubConfig("console");
TMCIConfig.register("enabled", false, 1, true, true /* FIXME only because can't be changed on the fly */, "TextModeClientInterfaceServer.enabled", "TextModeClientInterfaceServer.enabledLong", new TMCIEnabledCallback(core));
TMCIConfig.register("ssl", false, 1, true, true , "TextModeClientInterfaceServer.ssl", "TextModeClientInterfaceServer.sslLong", new TMCISSLCallback());
TMCIConfig.register("bindTo", NetworkInterface.DEFAULT_BIND_TO, 2, true, false, "TextModeClientInterfaceServer.bindTo", "TextModeClientInterfaceServer.bindToLong", new TMCIBindtoCallback(core));
TMCIConfig.register("allowedHosts", NetworkInterface.DEFAULT_BIND_TO, 2, true, false, "TextModeClientInterfaceServer.allowedHosts", "TextModeClientInterfaceServer.allowedHostsLong", new TMCIAllowedHostsCallback(core));
TMCIConfig.register("port", 2323, 1, true, false, "TextModeClientInterfaceServer.telnetPortNumber", "TextModeClientInterfaceServer.telnetPortNumberLong", new TCMIPortNumberCallback(core), false);
TMCIConfig.register("directEnabled", false, 1, true, false, "TextModeClientInterfaceServer.enableInputOutput", "TextModeClientInterfaceServer.enableInputOutputLong", new TMCIDirectEnabledCallback(core));
boolean TMCIEnabled = TMCIConfig.getBoolean("enabled");
int port = TMCIConfig.getInt("port");
String bind_ip = TMCIConfig.getString("bindTo");
String allowedHosts = TMCIConfig.getString("allowedHosts");
boolean direct = TMCIConfig.getBoolean("directEnabled");
if(SSL.available()) {
ssl = TMCIConfig.getBoolean("ssl");
}
if(TMCIEnabled)
server = new TextModeClientInterfaceServer(node, core, port, bind_ip, allowedHosts);
if(direct) {
HighLevelSimpleClient client = core.makeClient(RequestStarter.INTERACTIVE_PRIORITY_CLASS, true, false);
TextModeClientInterface directTMCI =
new TextModeClientInterface(node, core, client, core.getDownloadsDir(), System.in, System.out);
node.executor.execute(directTMCI, "Direct text mode interface");
core.setDirectTMCI(directTMCI);
}
TMCIConfig.finishedInitialization();
return server; // caller must call start()
}
static class TMCIEnabledCallback extends BooleanCallback {
final NodeClientCore core;
TMCIEnabledCallback(NodeClientCore core) {
this.core = core;
}
@Override
public Boolean get() {
return core.getTextModeClientInterface() != null;
}
@Override
public void set(Boolean val) throws InvalidConfigValueException {
if (get().equals(val))
return;
// FIXME implement - see bug #122
throw new InvalidConfigValueException("Cannot be updated on the fly");
}
@Override
public boolean isReadOnly() {
return true;
}
}
static class TMCISSLCallback extends BooleanCallback {
@Override
public Boolean get() {
return ssl;
}
@Override
public void set(Boolean val) throws InvalidConfigValueException {
if (get().equals(val))
return;
if(!SSL.available()) {
throw new InvalidConfigValueException("Enable SSL support before use ssl with TMCI");
}
ssl = val;
throw new InvalidConfigValueException("Cannot change SSL on the fly, please restart freenet");
}
@Override
public boolean isReadOnly() {
return true;
}
}
static class TMCIDirectEnabledCallback extends BooleanCallback {
final NodeClientCore core;
TMCIDirectEnabledCallback(NodeClientCore core) {
this.core = core;
}
@Override
public Boolean get() {
return core.getDirectTMCI() != null;
}
@Override
public void set(Boolean val) throws InvalidConfigValueException {
if (get().equals(val))
return;
// FIXME implement - see bug #122
throw new InvalidConfigValueException("Cannot be updated on the fly");
}
@Override
public boolean isReadOnly() {
return true;
}
}
static class TMCIBindtoCallback extends StringCallback {
final NodeClientCore core;
TMCIBindtoCallback(NodeClientCore core) {
this.core = core;
}
@Override
public String get() {
if(core.getTextModeClientInterface() != null)
return core.getTextModeClientInterface().bindTo;
else
return NetworkInterface.DEFAULT_BIND_TO;
}
@Override
public void set(String val) throws InvalidConfigValueException {
if(val.equals(get())) return;
String[] failedAddresses = core.getTextModeClientInterface().networkInterface.setBindTo(val, false);
if(failedAddresses != null) {
// This is an advanced option for reasons of reducing clutter,
// but it is expected to be used by regular users, not devs.
// So we translate the error messages.
throw new InvalidConfigValueException("could not change bind to: "+Arrays.toString(failedAddresses));
}
core.getTextModeClientInterface().bindTo = val;
}
}
static class TMCIAllowedHostsCallback extends StringCallback {
private final NodeClientCore core;
public TMCIAllowedHostsCallback(NodeClientCore core) {
this.core = core;
}
@Override
public String get() {
if (core.getTextModeClientInterface() != null) {
return core.getTextModeClientInterface().allowedHosts;
}
return NetworkInterface.DEFAULT_BIND_TO;
}
@Override
public void set(String val) throws InvalidConfigValueException {
if (!val.equals(get())) {
TextModeClientInterfaceServer server = core.getTextModeClientInterface();
if(server != null) {
try {
server.networkInterface.setAllowedHosts(val);
} catch(IllegalArgumentException e) {
throw new InvalidConfigValueException(e);
}
server.allowedHosts = val;
} else
throw new InvalidConfigValueException("Setting allowedHosts for TMCI (console) server when TMCI is disabled");
}
}
}
static class TCMIPortNumberCallback extends IntCallback {
final NodeClientCore core;
TCMIPortNumberCallback(NodeClientCore core) {
this.core = core;
}
@Override
public Integer get() {
if(core.getTextModeClientInterface()!=null)
return core.getTextModeClientInterface().port;
else
return 2323;
}
// TODO: implement it
@Override
public void set(Integer val) throws InvalidConfigValueException {
if (get().equals(val))
return;
core.getTextModeClientInterface().setPort(val);
}
}
/**
* Read commands, run them
*/
@Override
public void run() {
freenet.support.Logger.OSThread.logPID(this);
while(true) {
int curPort = port;
String tempBindTo = this.bindTo;
try {
networkInterface.setSoTimeout(1000);
} catch (SocketException e1) {
Logger.error(this, "Could not set timeout: "+e1, e1);
System.err.println("Could not start TMCI: "+e1);
e1.printStackTrace();
return;
}
while(isEnabled) {
// Maybe something has changed?
if(port != curPort) break;
if(!(this.bindTo.equals(tempBindTo))) break;
try {
Socket s = networkInterface.accept();
if(s == null)
continue; // timeout
InputStream in = s.getInputStream();
OutputStream out = s.getOutputStream();
TextModeClientInterface tmci =
new TextModeClientInterface(this, in, out);
n.executor.execute(tmci, "Text mode client interface handler for "+s.getPort());
} catch (SocketException e){
Logger.error(this, "Socket error : "+e, e);
} catch (IOException e) {
Logger.error(this, "TMCI failed to accept socket: "+e, e);
}
}
try{
networkInterface.close();
}catch (IOException e){
Logger.error(this, "Error shuting down TMCI", e);
}
}
}
public void setPort(int val) {
port = val;
}
}