Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Licensed to the Apache Software Foundation (ASF) under one or more
   * contributor license agreements.  See the NOTICE file distributed with
   * this work for additional information regarding copyright ownership.
   * The ASF 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
   *
   *     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 org.apache.tomcat.websocket;
 
 import static org.jboss.web.WebsocketsMessages.MESSAGES;
 
 import java.io.Reader;
 import java.util.List;
 import java.util.Set;
 
 
Utility class for internal use only within the org.apache.tomcat.websocket package.
 
 public class Util {
 
     private static final Queue<SecureRandomrandoms =
             new ConcurrentLinkedQueue<SecureRandom>();
 
     private Util() {
         // Hide default constructor
     }
 
 
     static boolean isControl(byte opCode) {
         return (opCode & 0x08) > 0;
     }
 
 
     static boolean isText(byte opCode) {
         return opCode == .;
     }
 
 
     static CloseCode getCloseCode(int code) {
         if (code > 2999 && code < 5000) {
             return .;
         }
         switch (code) {
             case 1000:
                 return .;
             case 1001:
                 return .;
             case 1002:
                 return .;
             case 1003:
                 return .;
             case 1004:
                 // Should not be used in a close frame
                 // return CloseCodes.RESERVED;
                 return .;
             case 1005:
                 // Should not be used in a close frame
                 // return CloseCodes.NO_STATUS_CODE;
                 return .;
            case 1006:
                // Should not be used in a close frame
                // return CloseCodes.CLOSED_ABNORMALLY;
                return .;
            case 1007:
                return .;
            case 1008:
                return .;
            case 1009:
                return .;
            case 1010:
                return .;
            case 1011:
                return .;
            case 1012:
                // Not in RFC6455
                // return CloseCodes.SERVICE_RESTART;
                return .;
            case 1013:
                // Not in RFC6455
                // return CloseCodes.TRY_AGAIN_LATER;
                return .;
            case 1015:
                // Should not be used in a close frame
                // return CloseCodes.TLS_HANDSHAKE_FAILURE;
                return .;
            default:
                return .;
        }
    }
    static byte[] generateMask() {
        // SecureRandom is not thread-safe so need to make sure only one thread
        // uses it at a time. In theory, the pool could grow to the same size
        // as the number of request processing threads. In reality it will be
        // a lot smaller.
        // Get a SecureRandom from the pool
        SecureRandom sr = .poll();
        // If one isn't available, generate a new one
        if (sr == null) {
            try {
                sr = SecureRandom.getInstance("SHA1PRNG");
            } catch (NoSuchAlgorithmException e) {
                // Fall back to platform default
                sr = new SecureRandom();
            }
        }
        // Generate the mask
        byte[] result = new byte[4];
        sr.nextBytes(result);
        // Put the SecureRandom back in the poll
        .add(sr);
        return result;
    }
    static Class<?> getMessageType(MessageHandler listener) {
        return Util.getGenericType(MessageHandler.class,
                listener.getClass()).getClazz();
    }
    public static Class<?> getDecoderType(Class<? extends Decoderdecoder) {
        return Util.getGenericType(Decoder.classdecoder).getClazz();
    }
    static Class<?> getEncoderType(Class<? extends Encoderencoder) {
        return Util.getGenericType(Encoder.classencoder).getClazz();
    }
    private static <T> TypeResult getGenericType(Class<T> type,
            Class<? extends T> clazz) {
        // Look to see if this class implements the generic MessageHandler<>
        // interface
        // Get all the interfaces
        Type[] interfaces = clazz.getGenericInterfaces();
        for (Type iface : interfaces) {
            // Only need to check interfaces that use generics
            if (iface instanceof ParameterizedType) {
                ParameterizedType pi = (ParameterizedTypeiface;
                // Look for the MessageHandler<> interface
                if (pi.getRawType() instanceof Class) {
                    if (type.isAssignableFrom((Class<?>) pi.getRawType())) {
                        return getTypeParameter(
                                clazzpi.getActualTypeArguments()[0]);
                    }
                }
            }
        }
        // Interface not found on this class. Look at the superclass.
        @SuppressWarnings("unchecked")
        Class<? extends T> superClazz =
                (Class<? extends T>) clazz.getSuperclass();
        TypeResult superClassTypeResult = getGenericType(typesuperClazz);
        int dimension = superClassTypeResult.getDimension();
        if (superClassTypeResult.getIndex() == -1 && dimension == 0) {
            // Superclass implements interface and defines explicit type for
            // MessageHandler<>
            return superClassTypeResult;
        }
        if (superClassTypeResult.getIndex() > -1) {
            // Superclass implements interface and defines unknown type for
            // MessageHandler<>
            // Map that unknown type to the generic types defined in this class
            ParameterizedType superClassType =
                    (ParameterizedTypeclazz.getGenericSuperclass();
            TypeResult result = getTypeParameter(clazz,
                    superClassType.getActualTypeArguments()[
                            superClassTypeResult.getIndex()]);
            result.incrementDimension(superClassTypeResult.getDimension());
            if (result.getClazz() != null && result.getDimension() > 0) {
                superClassTypeResult = result;
            } else {
                return result;
            }
        }
        if (superClassTypeResult.getDimension() > 0) {
            StringBuilder className = new StringBuilder();
            for (int i = 0; i < dimensioni++) {
                className.append('[');
            }
            className.append('L');
            className.append(superClassTypeResult.getClazz().getCanonicalName());
            className.append(';');
            Class<?> arrayClazz;
            try {
                arrayClazz = Class.forName(className.toString());
            } catch (ClassNotFoundException e) {
                throw new IllegalArgumentException(e);
            }
            return new TypeResult(arrayClazz, -1, 0);
        }
        // Error will be logged further up the call stack
        return null;
    }
    /*
     * For a generic parameter, return either the Class used or if the type
     * is unknown, the index for the type in definition of the class
     */
    private static TypeResult getTypeParameter(Class<?> clazzType argType) {
        if (argType instanceof Class<?>) {
            return new TypeResult((Class<?>) argType, -1, 0);
        } else if (argType instanceof ParameterizedType) {
            return new TypeResult((Class<?>)((ParameterizedTypeargType).getRawType(), -1, 0);
        } else if (argType instanceof GenericArrayType) {
            Type arrayElementType = ((GenericArrayTypeargType).getGenericComponentType();
            TypeResult result = getTypeParameter(clazzarrayElementType);
            result.incrementDimension(1);
            return result;
        } else {
            TypeVariable<?>[] tvs = clazz.getTypeParameters();
            for (int i = 0; i < tvs.lengthi++) {
                if (tvs[i].equals(argType)) {
                    return new TypeResult(nulli, 0);
                }
            }
            return null;
        }
    }
    public static boolean isPrimitive(Class<?> clazz) {
        if (clazz.isPrimitive()) {
            return true;
        } else if(clazz.equals(Boolean.class) ||
                clazz.equals(Byte.class) ||
                clazz.equals(Character.class) ||
                clazz.equals(Double.class) ||
                clazz.equals(Float.class) ||
                clazz.equals(Integer.class) ||
                clazz.equals(Long.class) ||
                clazz.equals(Short.class)) {
            return true;
        }
        return false;
    }
    public static Object coerceToType(Class<?> typeString value) {
        if (type.equals(String.class)) {
            return value;
        } else if (type.equals(boolean.class) || type.equals(Boolean.class)) {
            return Boolean.valueOf(value);
        } else if (type.equals(byte.class) || type.equals(Byte.class)) {
            return Byte.valueOf(value);
        } else if (value.length() == 1 &&
                (type.equals(char.class) || type.equals(Character.class))) {
            return Character.valueOf(value.charAt(0));
        } else if (type.equals(double.class) || type.equals(Double.class)) {
            return Double.valueOf(value);
        } else if (type.equals(float.class) || type.equals(Float.class)) {
            return Float.valueOf(value);
        } else if (type.equals(int.class) || type.equals(Integer.class)) {
            return Integer.valueOf(value);
        } else if (type.equals(long.class) || type.equals(Long.class)) {
            return Long.valueOf(value);
        } else if (type.equals(short.class) || type.equals(Short.class)) {
            return Short.valueOf(value);
        } else {
            throw .invalidType(valuetype.getName());
        }
    }
    public static List<DecoderEntrygetDecoders(
            Class<? extends Decoder>[] decoderClazzes)
                    throws DeploymentException{
        List<DecoderEntryresult = new ArrayList<DecoderEntry>();
        for (Class<? extends DecoderdecoderClazz : decoderClazzes) {
            // Need to instantiate decoder to ensure it is valid and that
            // deployment can be failed if it is not
            @SuppressWarnings("unused")
            Decoder instance;
            try {
                instance = decoderClazz.newInstance();
            } catch (InstantiationException e) {
                throw new DeploymentException(.cannotInstatiateDecoder(decoderClazz.getName()), e);
            } catch (IllegalAccessException e) {
                throw new DeploymentException(.cannotInstatiateDecoder(decoderClazz.getName()), e);
            }
            DecoderEntry entry = new DecoderEntry(
                    Util.getDecoderType(decoderClazz), decoderClazz);
            result.add(entry);
        }
        return result;
    }
            MessageHandler listenerEndpointConfig endpointConfig,
            Session session) {
        Class<?> target = Util.getMessageType(listener);
        // Will never be more than 2 types
        Set<MessageHandlerResultresults = new HashSet<MessageHandlerResult>(2);
        // Simple cases - handlers already accepts one of the types expected by
        // the frame handling code
        if (String.class.isAssignableFrom(target)) {
            MessageHandlerResult result =
                    new MessageHandlerResult(listener,
                            .);
            results.add(result);
        } else if (ByteBuffer.class.isAssignableFrom(target)) {
            MessageHandlerResult result =
                    new MessageHandlerResult(listener,
                            .);
            results.add(result);
        } else if (PongMessage.class.isAssignableFrom(target)) {
            MessageHandlerResult result =
                    new MessageHandlerResult(listener,
                            .);
            results.add(result);
        // Relatively simple cases - handler needs wrapping but no decoder to
        // convert it to one of the types expected by the frame handling code
        } else if (byte[].class.isAssignableFrom(target)) {
            MessageHandlerResult result = new MessageHandlerResult(
                    new PojoMessageHandlerWholeBinary(listener,
                            getOnMessageMethod(listener), session,
                            endpointConfignullnew Object[1], 0, true, -1,
                            false, -1),
                    .);
            results.add(result);
        } else if (InputStream.class.isAssignableFrom(target)) {
            MessageHandlerResult result = new MessageHandlerResult(
                    new PojoMessageHandlerWholeBinary(listener,
                            getOnMessageMethod(listener), session,
                            endpointConfignullnew Object[1], 0, true, -1,
                            true, -1),
                    .);
            results.add(result);
        } else if (Reader.class.isAssignableFrom(target)) {
            MessageHandlerResult result = new MessageHandlerResult(
                    new PojoMessageHandlerWholeText(listener,
                            getOnMessageMethod(listener), session,
                            endpointConfignullnew Object[1], 0, true, -1,
                            -1),
                    .);
            results.add(result);
        } else {
        // More complex case - listener that requires a decoder
            DecoderMatch decoderMatch;
            try {
                List<Class<? extends Decoder>> decoders =
                        endpointConfig.getDecoders();
                @SuppressWarnings("unchecked")
                List<DecoderEntrydecoderEntries = getDecoders(
                        decoders.toArray(new Class[decoders.size()]));
                decoderMatch = new DecoderMatch(targetdecoderEntries);
            } catch (DeploymentException e) {
                throw new IllegalArgumentException(e);
            }
            Method m = getOnMessageMethod(listener);
            if (decoderMatch.getBinaryDecoders().size() > 0) {
                MessageHandlerResult result = new MessageHandlerResult(
                        new PojoMessageHandlerWholeBinary(listenermsession,
                                endpointConfig,
                                decoderMatch.getBinaryDecoders(), new Object[1],
                                0, false, -1, false, -1),
                        .);
                results.add(result);
            }
            if (decoderMatch.getTextDecoders().size() > 0) {
                MessageHandlerResult result = new MessageHandlerResult(
                        new PojoMessageHandlerWholeText(listenermsession,
                                endpointConfig,
                                decoderMatch.getTextDecoders(), new Object[1],
                                0, false, -1, -1),
                        .);
                results.add(result);
            }
        }
        if (results.size() == 0) {
            throw .unknownHandler(listenertarget);
        }
        return results;
    }
    private static Method getOnMessageMethod(MessageHandler listener) {
        try {
            return listener.getClass().getMethod("onMessage"Object.class);
        } catch (NoSuchMethodException e) {
            throw .invalidMessageHandler(e);
        } catch ( SecurityException e) {
            throw .invalidMessageHandler(e);
        }
    }
    public static class DecoderMatch {
        private final List<Class<? extends Decoder>> textDecoders =
                new ArrayList<Class<? extends Decoder>>();
        private final List<Class<? extends Decoder>> binaryDecoders =
                new ArrayList<Class<? extends Decoder>>();
        public DecoderMatch(Class<?> targetList<DecoderEntrydecoderEntries) {
            for (DecoderEntry decoderEntry : decoderEntries) {
                if (decoderEntry.getClazz().isAssignableFrom(target)) {
                    if (Binary.class.isAssignableFrom(
                            decoderEntry.getDecoderClazz())) {
                        .add(decoderEntry.getDecoderClazz());
                        // willDecode() method means this decoder may or may not
                        // decode a message so need to carry on checking for
                        // other matches
                    } else if (BinaryStream.class.isAssignableFrom(
                            decoderEntry.getDecoderClazz())) {
                        .add(decoderEntry.getDecoderClazz());
                        // Stream decoders have to process the message so no
                        // more decoders can be matched
                        break;
                    } else if (Text.class.isAssignableFrom(
                            decoderEntry.getDecoderClazz())) {
                        .add(decoderEntry.getDecoderClazz());
                        // willDecode() method means this decoder may or may not
                        // decode a message so need to carry on checking for
                        // other matches
                    } else if (TextStream.class.isAssignableFrom(
                            decoderEntry.getDecoderClazz())) {
                        .add(decoderEntry.getDecoderClazz());
                        // Stream decoders have to process the message so no
                        // more decoders can be matched
                        break;
                    } else {
                        throw .unknownDecoderType(decoderEntry.getDecoderClazz().getName());
                    }
                }
            }
        }
        public List<Class<? extends Decoder>> getTextDecoders() {
            return ;
        }
        public List<Class<? extends Decoder>> getBinaryDecoders() {
            return ;
        }
        public boolean hasMatches() {
            return (.size() > 0) || (.size() > 0);
        }
    }
    private static class TypeResult {
        private final Class<?> clazz;
        private final int index;
        private int dimension;
        public TypeResult(Class<?> clazzint indexint dimension) {
            this.clazz;
            this. = index;
            this. = dimension;
        }
        public Class<?> getClazz() {
            return ;
        }
        public int getIndex() {
            return ;
        }
        public int getDimension() {
            return ;
        }
        public void incrementDimension(int inc) {
             += inc;
        }
    }
New to GrepCode? Check out our FAQ X