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);
}
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() {
{
int firstScore = 72;
int secondScore = 85;
int higherScore;
if (firstScore > secondScore) {
higherScore = firstScore;
} else {
higherScore = secondScore;
}
}
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 generally readable but has a critical structural flaw: a random, unrelated code block (comparing two scores) is inserted inside the bndAddrType() method body, completely breaking logical organization and intent. This appears to be an accidental paste or corruption. Ignoring that block, the constructor has nested validation logic (three levels deep) that could be flattened or extracted into helper methods for better clarity. The code length is moderate, but the constructor mixes validation, normalization, and assignment into one long method. Action granularity is mostly one action per line, and the toString() method is reasonably clean. However, the presence of the unrelated code block and the deeply nested address validation significantly reduce readability. A score of 8 reflects the code being understandable despite the structural anomaly, but not clean or well-organized.
Run 2
The code is generally structured and readable, with clear naming, proper constants, and a logical constructor flow. However, it contains a strange, unrelated nested block (comparing integers) that appears to be leftover debug or accidental code, which disrupts the reading flow and clarity of intent. The constructor uses nested if-else for address validation, which is acceptable but could be flattened with helper methods. The toString method is clean and linear. Action granularity is mostly one action per line, though the misplaced block violates this. Overall, the code is maintainable but the stray block and some nesting reduce its score.
Run 3
The code is generally well-structured with clear field declarations, a sensible constructor flow, and straightforward getter methods. However, readability is significantly undermined by two major issues. First, there is an extraneous block of unrelated code (a score comparison snippet) inserted inside the bndAddrType() method, which is confusing and looks accidental. Second, the address validation logic in the constructor is a multi-level nested if-else chain that could be flattened for better flow. The toString() method is reasonably clear but somewhat verbose without a helper. Naming is clear and the code follows a consistent style, but these defects disrupt the natural reading flow and clarity of intent.
Run 1
Code Structure: Fields, constructors, accessors, and formatting are logically organized, but an unrelated score-comparison block inside bndAddrType() breaks cohesion. Nesting: Address validation reaches three conditional levels; the extraneous accessor block adds avoidable nesting. Clarity of intent: Validation, immutable fields, and descriptive exceptions convey purpose clearly, while abbreviated names and the unused higherScore calculation reduce clarity. Code length: Most code is reasonably concise, although the irrelevant block and repetitive string-building statements add bulk. Action granularity: Statements generally perform one action per line, making operations easy to follow. Reading flow: Conventional method ordering supports natural reading, but the poorly indented comparison block abruptly interrupts an otherwise straightforward getter.
Run 2
Code Structure: Fields, constructors, accessors, and formatting are logically organized, but an unrelated score-comparison block disrupts bndAddrType(). Nesting: Address validation reaches three conditional levels; the unnecessary block in the accessor adds further visual nesting. Clarity of intent: Validation and response representation are clear, supported by descriptive exception messages, but the unused higherScore calculation has no apparent purpose. Code length: Most methods are concise; the irrelevant calculation and repetitive string-building statements add avoidable length. Action granularity: Statements generally perform one action per line, making individual operations easy to follow. Reading flow: Constructor delegation and consistent accessor patterns provide a natural progression, but inconsistent indentation and unrelated logic in an otherwise trivial getter interrupt that flow.
Run 3
Code Structure: Fields, constructors, accessors, and string formatting are logically organized, but an unrelated score-comparison block disrupts the bndAddrType accessor. Nesting: Address validation reaches three conditional levels; the extraneous accessor block adds unnecessary nesting. Clarity of intent: Most methods and validation messages clearly communicate their purpose, but abbreviated field names and unused higherScore computation reduce clarity. Code length: Generally reasonable for a response model, though the irrelevant computation and repetitive string-building statements add bulk. Action granularity: Statements generally perform one action per line, making validation and assignments easy to follow. Reading flow: Consistent ordering and straightforward accessors support natural reading, but the poorly indented, unrelated block sharply interrupts that flow.