package ganarchy.friendcode.sam;
import com.google.common.collect.ImmutableMap;
import java.util.Map;
import java.util.regex.Pattern;
/**
* An I2P SAM command.
*
* @param name The command name.
* @param parameters The parameters.
*/
record I2PSamCommand(String name, String opcode, Map<String, String> parameters) {
/**
* Creates a new I2P SAM command.
*
* @param name The command name.
* @param opcode The subcommand name, or null.
* @param parameters The parameters.
* @throws IllegalArgumentException If the command or parameters don't follow the expected format.
* @throws NullPointerException If anything (except for opcode) is null.
*/
public I2PSamCommand(final String name, final String opcode, final Map<String, String> parameters) {
this.name = name;
this.opcode = opcode;
this.parameters = ImmutableMap.copyOf(parameters);
// command formats:
// COMMAND SUBCOMMAND KEY KEY= KEY="" KEY=VALUE KEY=" " KEY="\"" KEY="\\"
// COMMAND
// PING[ arbitrary text]
// PONG[ arbitrary text]
// none of these may contain newlines (\n)
// edge-case: I2PRouter treats empty values as "true", while we distinguish empty values.
// it's not strictly specified how they are to be handled, but anyway.
// check newlines
if (this.name.contains("\n") || (this.opcode != null && this.opcode.contains("\n")) || this.parameters.entrySet().stream().anyMatch(arg -> arg.getKey().contains("\n") || arg.getValue().contains("\n"))) {
throw new IllegalArgumentException("commands may not contain embedded newlines");
}
if (this.name.isEmpty()) {
throw new IllegalArgumentException("name must not be empty");
}
// check for PING/PONG
if (this.name.equals("PING") || this.name.equals("PONG")) {
// reject parameters
if (!this.parameters.isEmpty()) {
throw new IllegalArgumentException("PING/PONG does not accept parameters");
}
// skip any other validation
return;
}
// everything else is fine
// NOTE: we don't special-case I2PRouter's weirdness with \"\"COMMAND\"\" and \"\"OPCODE\"\"
// for one, we require name != null and !name.isEmpty(), so \"\"COMMAND\"\" would error on I2PRouter anyway,
// for two, single-word commands don't take a subcommand, so it doesn't even matter if you set \"\"OPCODE\"\".
}
/**
* Creates a new I2P SAM command, with no parameters.
*
* @param name The command name.
* @param opcode The subcommand name, or null.
*/
public I2PSamCommand(final String name, final String opcode) {
this(name, opcode, ImmutableMap.of());
}
/**
* Builds the complete command line.
*
* @return The complete command line.
*/
public String buildCommandLine() {
final StringBuilder sb = new StringBuilder();
sb.append(escape(this.name, false));
if (this.opcode != null) {
sb.append(' ');
if (this.name.equals("PING") || this.name.equals("PONG")) {
sb.append(this.opcode);
} else {
sb.append(escape(this.opcode, false));
}
}
for (final var argument : parameters.entrySet()) {
sb.append(' ');
sb.append(escape(argument.getKey(), false));
sb.append('=');
sb.append(escape(argument.getValue(), true));
}
return sb.toString();
}
/**
* Parses the given command line and returns an I2PSamCommand.
*
* @param commandLine The command line, without terminating newline.
* @return The parsed command, or null if there was an error.
*/
public static I2PSamCommand parse(final String commandLine) {
// we're a bit more strict than I2PRouter in how we parse these, but that should be okay.
if (commandLine.isEmpty()) {
return null;
}
if (commandLine.contains("\n")) {
throw new IllegalArgumentException("commandLine may not contain embedded newlines");
}
final var rawParams = new StringBuilder(commandLine);
int index;
index = nextToken(rawParams);
final String name = rawParams.substring(0, index);
if (index == rawParams.length()) { // invariant: length() != 0
// COMMAND
// (includes PING/PONG with no data)
return new I2PSamCommand(name, null);
} else if (name.isEmpty() || rawParams.charAt(index) != ' ') {
throw new IllegalArgumentException("commandLine must start with a command");
}
rawParams.delete(0, index + 1);
if (name.equals("PING") || name.equals("PONG")) {
// PING arbitrary text
// PONG arbitrary text
return new I2PSamCommand(name, rawParams.toString());
}
// COMMAND SUBCOMMAND[ ...]
index = nextToken(rawParams);
final String opcode = rawParams.substring(0, index);
if (opcode.isEmpty()) { // also if length() == 0
// COMMAND =... or some other BS
// we do not currently accept trailing spaces or parameters for single-word commands coming from the bridge.
throw new IllegalArgumentException("expected subcommand");
} else if (index == rawParams.length()) { // invariant: length() != 0 (checked above)
// COMMAND SUBCOMMAND
return new I2PSamCommand(name, opcode);
} else if (rawParams.charAt(index) != ' ') { // index != length()
throw new IllegalArgumentException("expected subcommand");
}
rawParams.delete(0, index + 1);
// COMMAND SUBCOMMAND ...
final ImmutableMap.Builder<String, String> params = ImmutableMap.builder();
// params
while (!rawParams.isEmpty()) {
index = nextToken(rawParams);
String key = rawParams.substring(0, index);
if (key.isEmpty()) {
throw new IllegalArgumentException("expected parameter key");
} else if (index == rawParams.length()) {
// KEY
params.put(key, "");
rawParams.setLength(0);
} else if (rawParams.charAt(index) == ' ') {
// KEY ...
params.put(key, "");
rawParams.delete(0, index + 1);
} else if (rawParams.charAt(index) == '=') {
rawParams.delete(0, index + 1);
if (rawParams.length() == 0) {
// KEY=
params.put(key, "");
} else if (rawParams.charAt(0) == '"') {
// KEY="...
// just special-case it
rawParams.deleteCharAt(0);
for (; index < rawParams.length(); index++) {
final int c = rawParams.charAt(index);
if (c == '\r' || c == '"') {
// characters that must be escaped in quotes
break;
} else if (c == '\\') {
// skip next character
rawParams.deleteCharAt(index);
if (index == rawParams.length()) {
throw new IllegalArgumentException("unterminated escape");
}
}
}
if (index == rawParams.length()) {
// KEY="
throw new IllegalArgumentException("unterminated quote");
} else if (rawParams.charAt(index) == '"') {
// KEY=""...
final String value = rawParams.substring(0, index);
params.put(key, value);
if (index + 1 == rawParams.length()) {
// KEY=""
rawParams.delete(0, index + 1);
} else if (rawParams.charAt(index + 1) == ' ') {
// KEY="" ...
rawParams.delete(0, index + 2);
} else {
throw new IllegalArgumentException("malformed quote");
}
} else {
throw new IllegalArgumentException("malformed quote");
}
} else {
// KEY=...
index = nextToken(rawParams);
if (index == rawParams.length()) {
// KEY=VALUE
final String value = rawParams.substring(0, index);
params.put(key, value);
rawParams.delete(0, index);
} else if (rawParams.charAt(index) == '=') {
// KEY=VALUE=...
// just special-case it
for (; index < rawParams.length(); index++) {
final int c = rawParams.charAt(index);
if (c == ' ' || c == '\t' || c == '\f' || c == '\b' || c == '\r' || c == '"') {
// characters that must (generally) be escaped
break;
} else if (c == '\\') {
// skip next character
rawParams.deleteCharAt(index);
if (index == rawParams.length()) {
throw new IllegalArgumentException("unterminated escape");
}
}
}
final String value = rawParams.substring(0, index);
if (index == rawParams.length()) {
// KEY=VALUE=
params.put(key, value);
rawParams.delete(0, index);
} else if (rawParams.charAt(index) == ' ') {
// KEY=VALUE= ...
params.put(key, value);
rawParams.delete(0, index + 1);
} else {
throw new IllegalArgumentException("malformed parameter value");
}
} else if (rawParams.charAt(index) == ' ') {
// KEY=VALUE ...
final String value = rawParams.substring(0, index);
params.put(key, value);
rawParams.delete(0, index + 1);
} else {
throw new IllegalArgumentException("malformed parameter value");
}
}
} else {
throw new IllegalArgumentException("expected parameter key");
}
}
return new I2PSamCommand(name, opcode, params.build());
}
@Override
public String toString() {
// The built command line is likely nicer to use when debugging.
return this.buildCommandLine();
}
/**
* Escapes and optionally quotes a string.
*
* @param input The input string.
* @param valueSection Whether this is a value section.
* @return The escaped and optionally quoted string.
*/
private static String escape(final String input, final boolean valueSection) {
final StringBuilder sb = new StringBuilder(0);
int lastIndex = 0;
for (int index = 0; index < input.length(); index++) {
final int c = input.charAt(index);
final boolean escape;
if (c == '=') {
// only escaped outside of value section, but does not require quoting.
escape = !valueSection;
} else if (c == ' ' || c == '\t' || c == '\f' || c == '\b') {
// only escaped outside of value section. requires quoting.
escape = !valueSection;
if (valueSection) {
// make sure the sb isn't empty so it actually adds quotes
sb.append(input, lastIndex, index + 1);
lastIndex = index + 1;
}
} else if (c == '\r' || c == '"' || c == '\\') {
// always escaped
escape = true;
} else {
// never escaped
escape = false;
}
if (escape) {
sb.append(input, lastIndex, index);
sb.append('\\');
sb.append(c);
lastIndex = index + 1;
}
}
if (!sb.isEmpty()) {
sb.append(input, lastIndex, input.length());
if (valueSection) {
sb.insert(0, '"');
sb.append('"');
}
return sb.toString();
} else {
return input;
}
}
/**
* Parses the next token.
*
* @param rawParams The input being processed.
* @return The index of the end of the next token.
*/
private static int nextToken(final StringBuilder rawParams) {
int index;
for (index = 0; index < rawParams.length(); index++) {
final int c = rawParams.charAt(index);
if (c == ' ' || c == '\t' || c == '\f' || c == '\b' || c == '=' || c == '\r' || c == '"') {
// characters that must (generally) be escaped
break;
} else if (c == '\\') {
// skip next character
rawParams.deleteCharAt(index);
if (index == rawParams.length()) {
throw new IllegalArgumentException("unterminated escape");
}
}
}
return index;
}
}
