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, 0x0);
}
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() > 0xff) {
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 < 0x0 || bndPort > 0xffff) {
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(0x80);
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 separation of concerns: fields, constructors, accessors, and toString are logically ordered. Nesting is minimal, with only one validation block containing if-else chains. Intent is explicit through method names, validation messages, and Javadoc. Code length is appropriate—concise yet thorough in validation. Action granularity is good, with single actions per line mostly, though some conditionals could be split for readability. Reading flow is natural: validation first, then assignment. Minor improvements could include extracting the address validation block into a private method to reduce constructor length and flatten the bndAddr validation slightly. Overall, the code is highly readable with clear defensive programming, consistent naming conventions, and well-formed toString output logic.
Run 2
The code is well-structured and follows clean coding principles. The class has a clear single responsibility, fields are logically organized, and the constructor validates inputs sensibly. Nesting is moderate—only one conditional block exists, but it contains multiple branches for address type validation. Intent is clear from method and variable names, though some abbreviations like 'bnd' reduce clarity slightly. Code length is appropriate; no unnecessary duplication or bloat. Actions are generally one-per-line, especially in the toString method which follows a consistent append pattern. Reading flow is natural, with getters grouped and toString at the end. Minor improvements would be extracting the address validation logic into a separate method to reduce nesting and improve readability further, but overall this is professional-grade, readable code.
Run 3
The code is generally readable and well-structured. It follows a logical organization with clear field declarations and a straightforward constructor. Nesting is moderate but not egregious—validation branches are appropriately flat. Intent is clear: the class is a SOCKS5 command response with validation and getters. Action granularity is mostly one action per line, which enhances clarity. The toString method is verbose but conventional for Netty. However, the constructor mixes assignment, validation, and mutation (IDN.toASCII reassignment) in one block, which slightly muddies reading flow. Some error messages are verbose, but not excessively. Overall, this is maintainable and understandable code.
Run 1
Code Structure: Fields, constructors, accessors, and string formatting are logically organized, with validation grouped before assignment. Nesting: Address validation reaches three conditional levels, adding some complexity, while other methods remain flat. Clarity of intent: Types, method names, and descriptive exception messages make the purpose clear; abbreviated names such as bndAddr and hexadecimal constants slightly reduce accessibility. Code length: Appropriate overall, though repeated address-validation patterns and numerous append calls add verbosity. Action granularity: Each statement performs a focused action, with no crowded multi-action lines. Reading flow: Constructor delegation, validation, initialization, and simple accessors follow a natural sequence; toString is straightforward but somewhat repetitive.
Run 2
Code Structure: Clear organization into immutable fields, constructors, accessors, and string formatting. Nesting: Address validation reaches three conditional levels, adding some complexity, but remains manageable. Clarity of intent: Types, validation methods, and descriptive exception messages make the purpose clear; abbreviated bnd names and hexadecimal constants slightly reduce accessibility. Code length: Mostly concise, although repeated validation patterns and numerous StringBuilder append statements add verbosity. Action granularity: Statements generally perform one action per line, making execution easy to follow. Reading flow: Validation precedes field assignment, and methods follow a predictable order. Minor formatting issues, such as missing separation between the package declaration and imports, slightly weaken presentation.
Run 3
Code Structure: Well organized into immutable fields, constructors, accessors, and string formatting. Nesting: Address validation reaches three conditional levels, making the constructor slightly harder to scan, but nesting remains manageable. Clarity of intent: Types, validation helpers, and explicit error messages clearly communicate purpose; abbreviated bound-address names and hexadecimal limits require some interpretation. Code length: Mostly concise, although repetitive validation branches and StringBuilder appends add verbosity. Action granularity: Each statement generally performs one action, with validation, assignments, and formatting clearly separated. Reading flow: Natural progression from validation to initialization, then accessors and diagnostics; consistent formatting supports readability.