com.github.czyzby.websocket.data.WebSocketCloseCode Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of gdx-websocket Show documentation
Web sockets abstraction for LibGDX applications.
The newest version!
/* Copyright (C) 2015 Neo Visionaries Inc.
 *
 * Licensed 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
 *
 * http://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 com.github.czyzby.websocket.data;

/** Official close codes. Originally from the Neo Visionaries web socket library, modified to be an enum.
 *
 * @see RFC 6455, 7.4.1. Defined Status Codes */
public enum WebSocketCloseCode {
    /** 1000),  1000 indicates a normal closure, meaning that the purpose for which the connection was established
     * has been fulfilled.  */
    NORMAL(1000),

    /** 1001),  1001 indicates that an endpoint is "going away", such as a server going down or a browser having
     * navigated away from a page.  */
    AWAY(1001),

    /** 1002),  1002 indicates that an endpoint is terminating the connection due to a protocol error.  */
    UNCONFORMED(1002),

    /** 1003;  1003 indicates that an endpoint is terminating the connection because it has received a type of data
     * it cannot accept (e.g., an endpoint that understands only text data MAY send this if it receives a binary
     * message).  */
    UNACCEPTABLE(1003),

    /** 1005;  1005 is a reserved value and MUST NOT be set as a status code in a Close control frame by an
     * endpoint. It is designated for use in applications expecting a status code to indicate that no status code
     * was actually present.  */
    NONE(1005),

    /** 1006;  1006 is a reserved value and MUST NOT be set as a status code in a Close control frame by an
     * endpoint. It is designated for use in applications expecting a status code to indicate that the connection
     * was closed abnormally, e.g., without sending or receiving a Close control frame.  */
    ABNORMAL(1006),

    /** 1007;  1007 indicates that an endpoint is terminating the connection because it has received data within a
     * message that was not consistent with the type of the message (e.g., non-UTF-8 [
     * RFC3629] data within a text message).  */
    INCONSISTENT(1007),

    /** 1008;  1008 indicates that an endpoint is terminating the connection because it has received a message that
     * violates its policy. This is a generic status code that can be returned when there is no other more suitable
     * status code (e.g., 1003 or 1009) or if there is a need to hide specific details about the policy.  */
    VIOLATED(1008),

    /** 1009),  1009 indicates that an endpoint is terminating the connection because it has received a message that
     * is too big for it to process.  */
    OVERSIZE(1009),

    /** 1010;  1010 indicates that an endpoint (client) is terminating the connection because it has expected the
     * server to negotiate one or more extension, but the server didn't return them in the response message of the
     * WebSocket handshake. The list of extensions that are needed SHOULD appear in the /reason/ part of the Close
     * frame. Note that this status code is not used by the server, because it can fail the WebSocket handshake
     * instead.  */
    UNEXTENDED(1010),

    /** 1011),  1011 indicates that a server is terminating the connection because it encountered an unexpected
     * condition that prevented it from fulfilling the request.  */
    UNEXPECTED(1011),

    /** 1015;  1015 is a reserved value and MUST NOT be set as a status code in a Close control frame by an
     * endpoint. It is designated for use in applications expecting a status code to indicate that the connection
     * was closed due to a failure to perform a TLS handshake (e.g., the server certificate can't be
     * verified).  */
    INSECURE(1015);

    private final int code;

    private WebSocketCloseCode(final int code) {
        this.code = code;
    }

    /** @return actual value of close code. */
    public int getCode() {
        return code;
    }

    /** @param code web socket close code. Usually in 1000-1011 range.
     * @return close code enum constant connected with the passed code.
     * @throws WebSocketException if invalid code is given. */
    public static WebSocketCloseCode getByCode(final int code) throws WebSocketException {
        // Ugly, but works without extra meta-data, like a map.
        if (code == INSECURE.code) {
            return INSECURE;
        }
        if (code < NORMAL.code || code > UNEXPECTED.code || code == 1004) {
            throw new WebSocketException("Unexpected close code: " + code);
        }
        if (code < 1004) {
            return values()[code - 1000];
        }
        // There's no 1004:
        return values()[code - 1001];
    }

    /** @param code possibly valid close code.
     * @param alternative returned if code is invalid.
     * @return close code connected with the object or the alternative if code is invalid. */
    public static WebSocketCloseCode getByCodeOrElse(final int code, final WebSocketCloseCode alternative) {
        // Ugly, but works without extra meta-data, like a map.
        if (code == INSECURE.code) {
            return INSECURE;
        }
        if (code < NORMAL.code || code > UNEXPECTED.code || code == 1004) {
            return alternative;
        }
        if (code < 1004) {
            return values()[code - 1000];
        }
        // There's no 1004:
        return values()[code - 1001];
    }
}