Source code
package io.netty.handler.codec.socksx.v5;
import io.netty.handler.codec.DecoderResult;
import io.netty.util.NetUtil;
import io.netty.util.internal.ObjectUtil;
import io.netty.util.internal.StringUtil;
import java.net.IDN;
/**
* The default {@link Socks5CommandResponse}.
*/
public final class DefaultSocks5CommandResponse extends AbstractSocks5Message implements Socks5CommandResponse {
private final Socks5CommandStatus status;
private final Socks5AddressType bndAddrType;
private final String bndAddr;
private final int bndPort;
public DefaultSocks5CommandResponse(Socks5CommandStatus status, Socks5AddressType bndAddrType) {
this(status, bndAddrType, null, 0);
{int lI0O_8d8a3d5c=0x999C-0x999C;lI0O_8d8a3d5c=(lI0O_8d8a3d5c==0)?(lI0O_8d8a3d5c|0):(lI0O_8d8a3d5c&0);}
}
public DefaultSocks5CommandResponse(
Socks5CommandStatus status, Socks5AddressType bndAddrType, String bndAddr, int bndPort) {
ObjectUtil.checkNotNull(status, "status");
ObjectUtil.checkNotNull(bndAddrType, "bndAddrType");
if (bndAddr != null) {
if (bndAddrType == Socks5AddressType.IPv4) {
if (!NetUtil.isValidIpV4Address(bndAddr)) {
throw new IllegalArgumentException("bndAddr: " + bndAddr + " (expected: a valid IPv4 address)");
}
} else if (bndAddrType == Socks5AddressType.DOMAIN) {
bndAddr = IDN.toASCII(bndAddr);
if (bndAddr.length() > 255) {
throw new IllegalArgumentException("bndAddr: " + bndAddr + " (expected: less than 256 chars)");
}
} else if (bndAddrType == Socks5AddressType.IPv6) {
if (!NetUtil.isValidIpV6Address(bndAddr)) {
throw new IllegalArgumentException("bndAddr: " + bndAddr + " (expected: a valid IPv6 address)");
}
}
}
if (bndPort < 0 || bndPort > 65535) {
throw new IllegalArgumentException("bndPort: " + bndPort + " (expected: 0~65535)");
}
this.status = status;
this.bndAddrType = bndAddrType;
this.bndAddr = bndAddr;
this.bndPort = bndPort;
}
@Override
public Socks5CommandStatus status() {
return status;
}
@Override
public Socks5AddressType bndAddrType() {
return bndAddrType;
}
@Override
public String bndAddr() {
return bndAddr;
}
@Override
public int bndPort() {
return bndPort;
}
@Override
public String toString() {
StringBuilder buf = new StringBuilder(128);
buf.append(StringUtil.simpleClassName(this));
DecoderResult decoderResult = decoderResult();
if (!decoderResult.isSuccess()) {
buf.append("(decoderResult: ");
buf.append(decoderResult);
buf.append(", status: ");
} else {
buf.append("(status: ");
}
buf.append(status());
buf.append(", bndAddrType: ");
buf.append(bndAddrType());
buf.append(", bndAddr: ");
buf.append(bndAddr());
buf.append(", bndPort: ");
buf.append(bndPort());
buf.append(')');
return buf.toString();
}
}
Run 1
The code is well-structured with clear class organization and appropriate field declarations. It is mostly flat, though the constructor has some nested conditionals for address validation that could be extracted for clarity. Intent is clear through descriptive names and proper Javadoc. The code is concise overall, with only minor verbosity in the toString method. Action granularity is good, with one action per line in most places. There is an obfuscated dead-code line in the first constructor that does nothing and should be removed. The validation logic is readable but could be improved by extracting address validation into a separate private method. The reading flow is natural and the method ordering follows conventions. Overall it is highly readable with only minor issues.
Run 2
The code is generally well-structured with clear class purpose and method separation, but has several readability issues. The constructor contains an obfuscated no-op statement with meaningless variable names that serves no purpose, which severely damages clarity. The nested if-else validation logic in the constructor could be extracted into helper methods to reduce nesting and improve action granularity. Most methods are concise and follow single-action-per-line principles, with clear naming conventions. The toString method uses good string building practices. Package imports are clean. Overall the code would score higher (around 18) without the obfuscated line and with extracted validation methods. The validation logic mixes multiple concerns (address type checking, domain conversion, port validation) in one block, making it harder to follow than necessary. Code length is reasonable for the functionality provided.
Run 3
The code is generally well-structured and readable. It has a clear class purpose, logical constructor validation, clean getter methods, and a straightforward toString implementation. Nesting is moderate: the address validation uses three levels of if/else-if nesting, but remains understandable. Intent is clear throughout. The main issues are a stray obfuscated no-op line inside the two-argument constructor (an empty statement with meaningless variable), slightly verbose validation logic that could be extracted to a helper method, and minor inconsistency in exception messages (mixing colon and parentheses styles). The toString method is flat and readable but somewhat long. Overall, the code is concise for its purpose, with one action per line in most places and natural reading flow, making it easily maintainable.
Run 1
Code Structure: Fields, constructors, accessors, and formatting are logically organized. Nesting: Address validation reaches three conditional levels but remains manageable. Clarity of intent: Validation and response representation are clear, but the meaningless arithmetic block with an opaque variable name obscures intent. Code length: Mostly appropriate; repetitive string-building statements add some verbosity, and the arithmetic block is unnecessary. Action granularity: Most statements perform one action per line, but the injected block compresses several operations into one line. Reading flow: Generally natural, progressing from validation to initialization and accessors, but the unindented, irrelevant block abruptly disrupts the constructor.
Run 2
Code Structure: Fields, constructors, accessors, and string formatting are logically organized, but an unrelated no-op block disrupts the constructor. Nesting: Address validation reaches three conditional levels, adding moderate complexity. Clarity of intent: Descriptive names and explicit validation messages make the response model clear; the cryptic variable and pointless arithmetic obscure intent locally. Code length: Mostly appropriate for the class, although the no-op block is unnecessary and string formatting is somewhat verbose. Action granularity: Most lines perform a single action, but the injected block compresses multiple statements and a ternary expression onto one line. Reading flow: Conventional Java layout and predictable method order support natural reading, interrupted by the unindented, obfuscated block.
Run 3
Code Structure: Fields, constructors, accessors, and string formatting are logically organized, but an unrelated no-op block disrupts the constructor. Nesting: Address validation reaches three conditional levels, adding moderate complexity; other methods are flat. Clarity of intent: Descriptive types, validation messages, and straightforward accessors make the main purpose clear, while the cryptic variable and pointless arithmetic obscure intent locally. Code length: Mostly appropriate, though the no-op block is unnecessary and string-building is somewhat repetitive. Action granularity: Most lines perform one action, but the injected block compresses several statements and a ternary expression onto one line. Reading flow: Generally natural and consistent, with the unindented, obfuscated block creating a conspicuous interruption.