| /* Alert.java -- SSL Alert message. |
| Copyright (C) 2006 Free Software Foundation, Inc. |
| |
| This file is a part of GNU Classpath. |
| |
| GNU Classpath is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by |
| the Free Software Foundation; either version 2 of the License, or (at |
| your option) any later version. |
| |
| GNU Classpath is distributed in the hope that it will be useful, but |
| WITHOUT ANY WARRANTY; without even the implied warranty of |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| General Public License for more details. |
| |
| You should have received a copy of the GNU General Public License |
| along with GNU Classpath; if not, write to the Free Software |
| Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 |
| USA |
| |
| Linking this library statically or dynamically with other modules is |
| making a combined work based on this library. Thus, the terms and |
| conditions of the GNU General Public License cover the whole |
| combination. |
| |
| As a special exception, the copyright holders of this library give you |
| permission to link this library with independent modules to produce an |
| executable, regardless of the license terms of these independent |
| modules, and to copy and distribute the resulting executable under |
| terms of your choice, provided that you also meet, for each linked |
| independent module, the terms and conditions of the license of that |
| module. An independent module is a module which is not derived from |
| or based on this library. If you modify this library, you may extend |
| this exception to your version of the library, but you are not |
| obligated to do so. If you do not wish to do so, delete this |
| exception statement from your version. */ |
| |
| |
| package gnu.javax.net.ssl.provider; |
| |
| import java.io.PrintWriter; |
| import java.io.StringWriter; |
| |
| import java.nio.ByteBuffer; |
| |
| /** |
| * An alert message in the SSL protocol. Alerts are sent both as warnings |
| * which may allow execution to continue, or they may be fatal, which will |
| * halt this session. An alert object is composed of two enums -- the level, |
| * which indicates the seriousness of the alert, and the description, which |
| * indicates the reason for the alert. |
| * |
| * <pre> |
| * struct { |
| * AlertLevel level; |
| * AlertDescription description; |
| * } |
| * </pre> |
| */ |
| public final class Alert implements Constructed |
| { |
| |
| // Fields. |
| // ------------------------------------------------------------------------- |
| |
| /** The underlying byte buffer. */ |
| private final ByteBuffer buffer; |
| |
| // Constructor. |
| // ------------------------------------------------------------------------- |
| |
| public Alert (final ByteBuffer buffer) |
| { |
| this.buffer = buffer; |
| } |
| |
| public Alert (final Level level, final Description description) |
| { |
| level.getClass (); |
| description.getClass (); |
| ByteBuffer b = ByteBuffer.allocate (2); |
| b.put (0, (byte) level.getValue ()); |
| b.put (1, (byte) description.getValue ()); |
| this.buffer = b.asReadOnlyBuffer (); |
| } |
| |
| // Instance methods. |
| // ------------------------------------------------------------------------- |
| |
| public int length () |
| { |
| return 2; |
| } |
| |
| byte[] getEncoded() |
| { |
| byte[] buf = new byte[2]; |
| buffer.position (0); |
| buffer.get (buf); |
| return buf; |
| } |
| |
| public Level level() |
| { |
| return Level.forInteger (buffer.get (0) & 0xFF); |
| } |
| |
| public Description description() |
| { |
| return Description.forInteger (buffer.get (1) & 0xFF); |
| } |
| |
| public void setLevel (final Level level) |
| { |
| buffer.put (0, (byte) level.getValue ()); |
| } |
| |
| public void setDescription (final Description description) |
| { |
| buffer.put (1, (byte) description.getValue ()); |
| } |
| |
| public boolean equals (Object o) |
| { |
| if (!(o instanceof Alert)) |
| return false; |
| Alert that = (Alert) o; |
| return that.buffer.position (0).equals (buffer.position (0)); |
| } |
| |
| public int hashCode () |
| { |
| return buffer.getShort (0) & 0xFFFF; |
| } |
| |
| public String toString() |
| { |
| return toString (null); |
| } |
| |
| public String toString (final String prefix) |
| { |
| StringWriter str = new StringWriter (); |
| PrintWriter out = new PrintWriter (str); |
| if (prefix != null) out.print (prefix); |
| out.println ("struct {"); |
| if (prefix != null) out.print (prefix); |
| out.print (" level: "); |
| out.print (level ()); |
| out.println (";"); |
| if (prefix != null) out.print (prefix); |
| out.print (" description: "); |
| out.print (description ()); |
| out.println (";"); |
| if (prefix != null) out.print (prefix); |
| out.print ("} Alert;"); |
| return str.toString (); |
| } |
| |
| // Enumerations. |
| // ------------------------------------------------------------------------- |
| |
| /** |
| * The level enumeration. |
| * |
| * <pre> |
| * enum { warning(1), fatal(2), (255) } AlertLevel; |
| * </pre> |
| */ |
| public static enum Level |
| { |
| |
| WARNING (1), FATAL (2); |
| |
| private final int value; |
| |
| private Level(int value) |
| { |
| this.value = value; |
| } |
| |
| public static Level forInteger (final int value) |
| { |
| switch (value & 0xFF) |
| { |
| case 1: return WARNING; |
| case 2: return FATAL; |
| default: throw new IllegalArgumentException ("invalid alert level: " + value); |
| } |
| } |
| |
| public int getValue() |
| { |
| return value; |
| } |
| } |
| |
| /** |
| * The description enumeration. |
| */ |
| public static enum Description |
| { |
| CLOSE_NOTIFY ( 0), |
| UNEXPECTED_MESSAGE ( 10), |
| BAD_RECORD_MAC ( 20), |
| DECRYPTION_FAILED ( 21), |
| RECORD_OVERFLOW ( 22), |
| DECOMPRESSION_FAILURE ( 30), |
| HANDSHAKE_FAILURE ( 40), |
| NO_CERTIFICATE ( 41), |
| BAD_CERTIFICATE ( 42), |
| UNSUPPORTED_CERTIFICATE ( 43), |
| CERTIFICATE_REVOKED ( 44), |
| CERTIFICATE_EXPIRED ( 45), |
| CERTIFICATE_UNKNOWN ( 46), |
| ILLEGAL_PARAMETER ( 47), |
| UNKNOWN_CA ( 48), |
| ACCESS_DENIED ( 49), |
| DECODE_ERROR ( 50), |
| DECRYPT_ERROR ( 51), |
| EXPORT_RESTRICTION ( 60), |
| PROTOCOL_VERSION ( 70), |
| INSUFFICIENT_SECURITY ( 71), |
| INTERNAL_ERROR ( 80), |
| USER_CANCELED ( 90), |
| NO_RENEGOTIATION (100), |
| UNSUPPORTED_EXTENSION (110), |
| CERTIFICATE_UNOBTAINABLE (111), |
| UNRECOGNIZED_NAME (112), |
| BAD_CERTIFICATE_STATUS_RESPONSE (113), |
| BAD_CERTIFICATE_HASH_VALUE (114), |
| UNKNOWN_SRP_USERNAME (120), |
| MISSING_SRP_USERNAME (121); |
| |
| private final int value; |
| |
| private Description(int value) |
| { |
| this.value = value; |
| } |
| |
| /** |
| * Return an alert description object based on the specified integer |
| * value. |
| * |
| * @param value The raw description value. |
| * @return The appropriate description object. |
| */ |
| public static Description forInteger (final int value) |
| { |
| switch (value & 0xFF) |
| { |
| case 0: return CLOSE_NOTIFY; |
| case 10: return UNEXPECTED_MESSAGE; |
| case 20: return BAD_RECORD_MAC; |
| case 21: return DECRYPTION_FAILED; |
| case 22: return RECORD_OVERFLOW; |
| case 30: return DECOMPRESSION_FAILURE; |
| case 40: return HANDSHAKE_FAILURE; |
| case 41: return NO_CERTIFICATE; |
| case 42: return BAD_CERTIFICATE; |
| case 43: return UNSUPPORTED_CERTIFICATE; |
| case 44: return CERTIFICATE_REVOKED; |
| case 45: return CERTIFICATE_EXPIRED; |
| case 46: return CERTIFICATE_UNKNOWN; |
| case 47: return ILLEGAL_PARAMETER; |
| case 48: return UNKNOWN_CA; |
| case 49: return ACCESS_DENIED; |
| case 50: return DECODE_ERROR; |
| case 51: return DECRYPT_ERROR; |
| case 60: return EXPORT_RESTRICTION; |
| case 70: return PROTOCOL_VERSION; |
| case 71: return INSUFFICIENT_SECURITY; |
| case 80: return INTERNAL_ERROR; |
| case 90: return USER_CANCELED; |
| case 100: return NO_RENEGOTIATION; |
| case 120: return UNKNOWN_SRP_USERNAME; |
| case 121: return MISSING_SRP_USERNAME; |
| default: throw new IllegalArgumentException("unknown alert description: " + value); |
| } |
| } |
| |
| public int getValue() |
| { |
| return value; |
| } |
| } |
| } |