io.netty.handler.codec.http.HttpVersion Maven / Gradle / Ivy
Go to download
This artifact provides a single jar that contains all classes required to use remote EJB and JMS, including
all dependencies. It is intended for use by those not using maven, maven users should just import the EJB and
JMS BOM's instead (shaded JAR's cause lots of problems with maven, as it is very easy to inadvertently end up
with different versions on classes on the class path).
/*
* Copyright 2012 The Netty Project
*
* The Netty Project licenses this file to you under the Apache License,
* version 2.0 (the "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at:
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations
* under the License.
*/
package io.netty.handler.codec.http;
import static io.netty.util.internal.ObjectUtil.checkPositiveOrZero;
import static io.netty.util.internal.ObjectUtil.checkNonEmptyAfterTrim;
import io.netty.buffer.ByteBuf;
import io.netty.util.CharsetUtil;
import io.netty.util.internal.ObjectUtil;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
* The version of HTTP or its derived protocols, such as
* RTSP and
* ICAP.
*/
public class HttpVersion implements Comparable {
private static final Pattern VERSION_PATTERN =
Pattern.compile("(\\S+)/(\\d+)\\.(\\d+)");
static final String HTTP_1_0_STRING = "HTTP/1.0";
static final String HTTP_1_1_STRING = "HTTP/1.1";
/**
* HTTP/1.0
*/
public static final HttpVersion HTTP_1_0 = new HttpVersion("HTTP", 1, 0, false, true);
/**
* HTTP/1.1
*/
public static final HttpVersion HTTP_1_1 = new HttpVersion("HTTP", 1, 1, true, true);
/**
* Returns an existing or new {@link HttpVersion} instance which matches to
* the specified protocol version string. If the specified {@code text} is
* equal to {@code "HTTP/1.0"}, {@link #HTTP_1_0} will be returned. If the
* specified {@code text} is equal to {@code "HTTP/1.1"}, {@link #HTTP_1_1}
* will be returned. Otherwise, a new {@link HttpVersion} instance will be
* returned.
*/
public static HttpVersion valueOf(String text) {
ObjectUtil.checkNotNull(text, "text");
// super fast-path
if (text == HTTP_1_1_STRING) {
return HTTP_1_1;
} else if (text == HTTP_1_0_STRING) {
return HTTP_1_0;
}
text = text.trim();
if (text.isEmpty()) {
throw new IllegalArgumentException("text is empty (possibly HTTP/0.9)");
}
// Try to match without convert to uppercase first as this is what 99% of all clients
// will send anyway. Also there is a change to the RFC to make it clear that it is
// expected to be case-sensitive
//
// See:
// * https://trac.tools.ietf.org/wg/httpbis/trac/ticket/1
// * https://trac.tools.ietf.org/wg/httpbis/trac/wiki
//
HttpVersion version = version0(text);
if (version == null) {
version = new HttpVersion(text, true);
}
return version;
}
private static HttpVersion version0(String text) {
if (HTTP_1_1_STRING.equals(text)) {
return HTTP_1_1;
}
if (HTTP_1_0_STRING.equals(text)) {
return HTTP_1_0;
}
return null;
}
private final String protocolName;
private final int majorVersion;
private final int minorVersion;
private final String text;
private final boolean keepAliveDefault;
private final byte[] bytes;
/**
* Creates a new HTTP version with the specified version string. You will
* not need to create a new instance unless you are implementing a protocol
* derived from HTTP, such as
* RTSP and
* ICAP.
*
* @param keepAliveDefault
* {@code true} if and only if the connection is kept alive unless
* the {@code "Connection"} header is set to {@code "close"} explicitly.
*/
public HttpVersion(String text, boolean keepAliveDefault) {
text = checkNonEmptyAfterTrim(text, "text").toUpperCase();
Matcher m = VERSION_PATTERN.matcher(text);
if (!m.matches()) {
throw new IllegalArgumentException("invalid version format: " + text);
}
protocolName = m.group(1);
majorVersion = Integer.parseInt(m.group(2));
minorVersion = Integer.parseInt(m.group(3));
this.text = protocolName + '/' + majorVersion + '.' + minorVersion;
this.keepAliveDefault = keepAliveDefault;
bytes = null;
}
/**
* Creates a new HTTP version with the specified protocol name and version
* numbers. You will not need to create a new instance unless you are
* implementing a protocol derived from HTTP, such as
* RTSP and
* ICAP
*
* @param keepAliveDefault
* {@code true} if and only if the connection is kept alive unless
* the {@code "Connection"} header is set to {@code "close"} explicitly.
*/
public HttpVersion(
String protocolName, int majorVersion, int minorVersion,
boolean keepAliveDefault) {
this(protocolName, majorVersion, minorVersion, keepAliveDefault, false);
}
private HttpVersion(
String protocolName, int majorVersion, int minorVersion,
boolean keepAliveDefault, boolean bytes) {
protocolName = checkNonEmptyAfterTrim(protocolName, "protocolName").toUpperCase();
for (int i = 0; i < protocolName.length(); i ++) {
if (Character.isISOControl(protocolName.charAt(i)) ||
Character.isWhitespace(protocolName.charAt(i))) {
throw new IllegalArgumentException("invalid character in protocolName");
}
}
checkPositiveOrZero(majorVersion, "majorVersion");
checkPositiveOrZero(minorVersion, "minorVersion");
this.protocolName = protocolName;
this.majorVersion = majorVersion;
this.minorVersion = minorVersion;
text = protocolName + '/' + majorVersion + '.' + minorVersion;
this.keepAliveDefault = keepAliveDefault;
if (bytes) {
this.bytes = text.getBytes(CharsetUtil.US_ASCII);
} else {
this.bytes = null;
}
}
/**
* Returns the name of the protocol such as {@code "HTTP"} in {@code "HTTP/1.0"}.
*/
public String protocolName() {
return protocolName;
}
/**
* Returns the name of the protocol such as {@code 1} in {@code "HTTP/1.0"}.
*/
public int majorVersion() {
return majorVersion;
}
/**
* Returns the name of the protocol such as {@code 0} in {@code "HTTP/1.0"}.
*/
public int minorVersion() {
return minorVersion;
}
/**
* Returns the full protocol version text such as {@code "HTTP/1.0"}.
*/
public String text() {
return text;
}
/**
* Returns {@code true} if and only if the connection is kept alive unless
* the {@code "Connection"} header is set to {@code "close"} explicitly.
*/
public boolean isKeepAliveDefault() {
return keepAliveDefault;
}
/**
* Returns the full protocol version text such as {@code "HTTP/1.0"}.
*/
@Override
public String toString() {
return text();
}
@Override
public int hashCode() {
return (protocolName().hashCode() * 31 + majorVersion()) * 31 +
minorVersion();
}
@Override
public boolean equals(Object o) {
if (!(o instanceof HttpVersion)) {
return false;
}
HttpVersion that = (HttpVersion) o;
return minorVersion() == that.minorVersion() &&
majorVersion() == that.majorVersion() &&
protocolName().equals(that.protocolName());
}
@Override
public int compareTo(HttpVersion o) {
int v = protocolName().compareTo(o.protocolName());
if (v != 0) {
return v;
}
v = majorVersion() - o.majorVersion();
if (v != 0) {
return v;
}
return minorVersion() - o.minorVersion();
}
void encode(ByteBuf buf) {
if (bytes == null) {
buf.writeCharSequence(text, CharsetUtil.US_ASCII);
} else {
buf.writeBytes(bytes);
}
}
}