/** * Parses an annotation type definition * * @param docClass * @return */ protected static Annotation ParseAnnotation(ClassDoc docClass) { AnnotationTypeDoc docAnnotation = (AnnotationTypeDoc) docClass; assert (docAnnotation != null); Annotation xmlAnnotation = new Annotation(); xmlAnnotation.name = docClass.name(); xmlAnnotation.qualifiedName = docClass.qualifiedName(); xmlAnnotation.comment = docClass.commentText(); xmlAnnotation.isIncluded = docClass.isIncluded(); xmlAnnotation.scope = DetermineScope(docClass); AnnotationTypeElementDoc[] elements = docAnnotation.elements(); if (elements != null && elements.length > 0) { ArrayList<AnnotationElement> elementList = new ArrayList<AnnotationElement>(); for (AnnotationTypeElementDoc element : elements) { elementList.add(ParseAnnotationElement(element)); } xmlAnnotation.elements = elementList.toArray(new AnnotationElement[] {}); } else { log.debug("No elements in annotation: " + docClass.name()); } xmlAnnotation.annotationInstances = ParseAnnotationInstances(docClass.annotations(), docClass.qualifiedName()); return xmlAnnotation; }
/** * Parse a method declaration. The declaration should be in the following format: * * <p>fully-qualified-method-name (args) * * <p>where the arguments are comma separated and all arguments other than primitives should have * fully qualified names. Arrays are indicating by trailing brackets. For example: * * <p>int int[] int[][] java.lang.String java.util.Date[] * * <p>The arguments are translated into BCEL types and a MethodDef is returned. */ private MethodDef parse_method(StrTok st) { // Get the method name String method_name = st.need_word(); // Get the opening paren st.need("("); // Read the arguments ArrayList<String> args = new ArrayList<String>(); String tok = st.nextToken(); if (tok != ")") { st.pushBack(); do { tok = st.need_word(); args.add(tok); } while (st.nextToken() == ","); st.pushBack(); st.need(")"); } // Convert the arguments to Type Type[] targs = new Type[args.size()]; for (int ii = 0; ii < args.size(); ii++) { targs[ii] = BCELUtil.classname_to_type(args.get(ii)); } return new MethodDef(method_name, targs); }
private static ArrayList parseDNchain(String dnChain) { if (dnChain == null) { throw new IllegalArgumentException("The DN chain must not be null."); // $NON-NLS-1$ } ArrayList parsed = new ArrayList(); int startIndex = 0; startIndex = skipSpaces(dnChain, startIndex); while (startIndex < dnChain.length()) { int endIndex = startIndex; boolean inQuote = false; out: while (endIndex < dnChain.length()) { char c = dnChain.charAt(endIndex); switch (c) { case '"': inQuote = !inQuote; break; case '\\': endIndex++; // skip the escaped char break; case ';': if (!inQuote) break out; } endIndex++; } if (endIndex > dnChain.length()) { throw new IllegalArgumentException("unterminated escape"); } parsed.add(dnChain.substring(startIndex, endIndex)); startIndex = endIndex + 1; startIndex = skipSpaces(dnChain, startIndex); } return parsed; }
protected void checkRoot(SimulatedArchivalUnit sau) { log.debug("checkRoot()"); CachedUrlSet set = sau.getAuCachedUrlSet(); Iterator setIt = set.flatSetIterator(); ArrayList childL = new ArrayList(1); CachedUrlSet cus = null; while (setIt.hasNext()) { cus = (CachedUrlSet) setIt.next(); childL.add(cus.getUrl()); } String urlRoot = sau.getUrlRoot(); String[] expectedA = new String[1]; expectedA[0] = urlRoot; assertIsomorphic(expectedA, childL); setIt = cus.flatSetIterator(); childL = new ArrayList(7); while (setIt.hasNext()) { childL.add(((CachedUrlSetNode) setIt.next()).getUrl()); } expectedA = new String[] { urlRoot + "/001file.html", urlRoot + "/001file.txt", urlRoot + "/002file.html", urlRoot + "/002file.txt", urlRoot + "/branch1", urlRoot + "/branch2", urlRoot + "/index.html" }; assertIsomorphic(expectedA, childL); }
protected void checkLeaf(SimulatedArchivalUnit sau) { log.debug("checkLeaf()"); String parent = sau.getUrlRoot() + "/branch1"; CachedUrlSetSpec spec = new RangeCachedUrlSetSpec(parent); CachedUrlSet set = sau.makeCachedUrlSet(spec); Iterator setIt = set.contentHashIterator(); ArrayList childL = new ArrayList(16); while (setIt.hasNext()) { childL.add(((CachedUrlSetNode) setIt.next()).getUrl()); } String[] expectedA = new String[] { parent, parent + "/001file.html", parent + "/001file.txt", parent + "/002file.html", parent + "/002file.txt", parent + "/branch1", parent + "/branch1/001file.html", parent + "/branch1/001file.txt", parent + "/branch1/002file.html", parent + "/branch1/002file.txt", parent + "/branch1/index.html", parent + "/branch2", parent + "/branch2/001file.html", parent + "/branch2/001file.txt", parent + "/branch2/002file.html", parent + "/branch2/002file.txt", parent + "/branch2/index.html", parent + "/index.html", }; assertIsomorphic(expectedA, childL); }
/** * Get the active cipher suites. * * <p>In TLS 1.1, many weak or vulnerable cipher suites were obsoleted, such as * TLS_RSA_EXPORT_WITH_RC4_40_MD5. The implementation MUST NOT negotiate these cipher suites in * TLS 1.1 or later mode. * * <p>Therefore, when the active protocols only include TLS 1.1 or later, the client cannot * request to negotiate those obsoleted cipher suites. That is, the obsoleted suites should not be * included in the client hello. So we need to create a subset of the enabled cipher suites, the * active cipher suites, which does not contain obsoleted cipher suites of the minimum active * protocol. * * <p>Return empty list instead of null if no active cipher suites. */ CipherSuiteList getActiveCipherSuites() { if (activeCipherSuites == null) { if (activeProtocols == null) { activeProtocols = getActiveProtocols(); } ArrayList<CipherSuite> suites = new ArrayList<>(); if (!(activeProtocols.collection().isEmpty()) && activeProtocols.min.v != ProtocolVersion.NONE.v) { for (CipherSuite suite : enabledCipherSuites.collection()) { if (suite.obsoleted > activeProtocols.min.v && suite.supported <= activeProtocols.max.v) { if (algorithmConstraints.permits( EnumSet.of(CryptoPrimitive.KEY_AGREEMENT), suite.name, null)) { suites.add(suite); } } else if (debug != null && Debug.isOn("verbose")) { if (suite.obsoleted <= activeProtocols.min.v) { System.out.println("Ignoring obsoleted cipher suite: " + suite); } else { System.out.println("Ignoring unsupported cipher suite: " + suite); } } } } activeCipherSuites = new CipherSuiteList(suites); } return activeCipherSuites; }
static Method[] getOverridableMethods(Class c) { ArrayList<Method> list = new ArrayList<Method>(); HashSet<String> skip = new HashSet<String>(); while (c != null) { Method[] methods = c.getDeclaredMethods(); for (int i = 0; i < methods.length; i++) { String methodKey = methods[i].getName() + getMethodSignature(methods[i], methods[i].getParameterTypes()); if (skip.contains(methodKey)) continue; // skip this method int mods = methods[i].getModifiers(); if (Modifier.isStatic(mods)) continue; if (Modifier.isFinal(mods)) { // Make sure we don't add a final method to the list // of overridable methods. skip.add(methodKey); continue; } if (Modifier.isPublic(mods) || Modifier.isProtected(mods)) { list.add(methods[i]); skip.add(methodKey); } } c = c.getSuperclass(); } return list.toArray(new Method[list.size()]); }
/* * Get the active protocol versions. * * In TLS 1.1, many weak or vulnerable cipher suites were obsoleted, * such as TLS_RSA_EXPORT_WITH_RC4_40_MD5. The implementation MUST NOT * negotiate these cipher suites in TLS 1.1 or later mode. * * For example, if "TLS_RSA_EXPORT_WITH_RC4_40_MD5" is the * only enabled cipher suite, the client cannot request TLS 1.1 or * later, even though TLS 1.1 or later is enabled. We need to create a * subset of the enabled protocols, called the active protocols, which * contains protocols appropriate to the list of enabled Ciphersuites. * * Return empty list instead of null if no active protocol versions. */ ProtocolList getActiveProtocols() { if (activeProtocols == null) { ArrayList<ProtocolVersion> protocols = new ArrayList<>(4); for (ProtocolVersion protocol : enabledProtocols.collection()) { boolean found = false; for (CipherSuite suite : enabledCipherSuites.collection()) { if (suite.isAvailable() && suite.obsoleted > protocol.v && suite.supported <= protocol.v) { if (algorithmConstraints.permits( EnumSet.of(CryptoPrimitive.KEY_AGREEMENT), suite.name, null)) { protocols.add(protocol); found = true; break; } else if (debug != null && Debug.isOn("verbose")) { System.out.println("Ignoring disabled cipher suite: " + suite + " for " + protocol); } } else if (debug != null && Debug.isOn("verbose")) { System.out.println("Ignoring unsupported cipher suite: " + suite + " for " + protocol); } } if (!found && (debug != null) && Debug.isOn("handshake")) { System.out.println("No available cipher suite for " + protocol); } } activeProtocols = new ProtocolList(protocols); } return activeProtocols; }
String[] readFile(String fn) throws IOException { BufferedReader br = new BufferedReader(new FileReader(fn)); String s; ArrayList al = new ArrayList(); while ((s = br.readLine()) != null) { al.add(s); } return (String[]) al.toArray(new String[0]); }
void isConnectable(SelectionKey k) { EventableSocketChannel ec = (EventableSocketChannel) k.attachment(); long b = ec.getBinding(); try { if (ec.finishConnecting()) eventCallback(b, EM_CONNECTION_COMPLETED, null); else UnboundConnections.add(b); } catch (IOException e) { UnboundConnections.add(b); } }
void isWritable(SelectionKey k) { EventableChannel ec = (EventableChannel) k.attachment(); long b = ec.getBinding(); if (ec.isWatchOnly()) { if (ec.isNotifyWritable()) eventCallback(b, EM_CONNECTION_NOTIFY_WRITABLE, null); } else { try { if (!ec.writeOutboundData()) UnboundConnections.add(b); } catch (IOException e) { UnboundConnections.add(b); } } }
/* * Convert an array of signers into an array of concatenated certificate * arrays. */ private static java.security.cert.Certificate[] mapSignersToCertArray(CodeSigner[] signers) { if (signers != null) { ArrayList certChains = new ArrayList(); for (int i = 0; i < signers.length; i++) { certChains.addAll(signers[i].getSignerCertPath().getCertificates()); } // Convert into a Certificate[] return (java.security.cert.Certificate[]) certChains.toArray(new java.security.cert.Certificate[certChains.size()]); } return null; }
public long installOneshotTimer(int milliseconds) { long s = createBinding(); long deadline = new Date().getTime() + milliseconds; if (Timers.containsKey(deadline)) { Timers.get(deadline).add(s); } else { ArrayList<Long> callbacks = new ArrayList<Long>(); callbacks.add(s); Timers.put(deadline, callbacks); } return s; }
static Method[] getOverridableMethods(Class<?> clazz) { ArrayList<Method> list = new ArrayList<Method>(); HashSet<String> skip = new HashSet<String>(); // Check superclasses before interfaces so we always choose // implemented methods over abstract ones, even if a subclass // re-implements an interface already implemented in a superclass // (e.g. java.util.ArrayList) for (Class<?> c = clazz; c != null; c = c.getSuperclass()) { appendOverridableMethods(c, list, skip); } for (Class<?> c = clazz; c != null; c = c.getSuperclass()) { for (Class<?> intf : c.getInterfaces()) appendOverridableMethods(intf, list, skip); } return list.toArray(new Method[list.size()]); }
static String[] getFontList() { init(); ArrayList fontNames = new ArrayList(); Iterator fonts = fontNameMap.keySet().iterator(); int dotidx; while (fonts.hasNext()) { String fontname = (String) fonts.next(); if ((dotidx = fontname.indexOf('.')) == -1) dotidx = fontname.length(); fontname = fontname.substring(0, dotidx); if (!fontNames.contains(fontname)) fontNames.add(fontname); } return (String[]) fontNames.toArray(new String[fontNames.size()]); }
public static String[] getZipList(String zipFile) throws ZipException, IOException { File file = new File(zipFile); ZipFile zip = new ZipFile(file); Enumeration<? extends ZipEntry> zipFileEntries = zip.entries(); ArrayList<String> files = new ArrayList<String>(); // Process each entry while (zipFileEntries.hasMoreElements()) { // grab a zip file entry ZipEntry entry = (ZipEntry) zipFileEntries.nextElement(); String currentEntry = entry.getName(); files.add(currentEntry); } return files.toArray(new String[files.size()]); }
/** Execute the system command 'cmd' and fill an ArrayList with the results. */ public static ArrayList<String> executeSystemCommand(String cmd) { if (debug) System.out.println("cmd: " + cmd); ArrayList<String> list = new ArrayList<>(); try (BufferedReader br = new BufferedReader( new InputStreamReader(RUNTIME.exec(/*comSpec +*/ cmd).getInputStream()))) { for (String line = null; (line = br.readLine()) != null; ) { if (debug) System.out.println(line); list.add(line); } } catch (IOException e) { e.printStackTrace(); } return list; }
/** * Parses a constructor type definition * * @param docConstructor * @return */ protected static Constructor ParseConstructor(ConstructorDoc docConstructor) { assert (docConstructor != null); Constructor xmlConstructor = new Constructor(); xmlConstructor.name = docConstructor.name(); xmlConstructor.comment = docConstructor.commentText(); xmlConstructor.scope = DetermineScope(docConstructor); xmlConstructor.isVarArgs = docConstructor.isVarArgs(); xmlConstructor.isDefault = docConstructor.position().line() == docConstructor.containingClass().position().line(); Parameter[] parameters = docConstructor.parameters(); if (parameters != null && parameters.length > 0) { ParamTag[] paramComments = docConstructor.paramTags(); ArrayList<Param> methodList = new ArrayList<Param>(); for (Parameter parameter : parameters) { ParamTag paramComment = null; // look to see if this parameter has comments // if so, paramComment will be set for (ParamTag testParam : paramComments) { String testParamName = testParam.parameterName(); if (testParamName != null) { if (testParamName.compareTo(parameter.name()) == 0) { paramComment = testParam; break; } } } methodList.add(ParseParameter(parameter, paramComment)); } xmlConstructor.parameters = methodList.toArray(new Param[] {}); } else { log.debug("No parameters for method: " + docConstructor.name()); } // parse annotations for the constructor xmlConstructor.annotationInstances = ParseAnnotationInstances(docConstructor.annotations(), docConstructor.qualifiedName()); return xmlConstructor; }
void isReadable(SelectionKey k) { EventableChannel ec = (EventableChannel) k.attachment(); long b = ec.getBinding(); if (ec.isWatchOnly()) { if (ec.isNotifyReadable()) eventCallback(b, EM_CONNECTION_NOTIFY_READABLE, null); } else { myReadBuffer.clear(); try { ec.readInboundData(myReadBuffer); myReadBuffer.flip(); if (myReadBuffer.limit() > 0) { if (ProxyConnections != null) { EventableChannel target = ProxyConnections.get(b); if (target != null) { ByteBuffer myWriteBuffer = ByteBuffer.allocate(myReadBuffer.limit()); myWriteBuffer.put(myReadBuffer); myWriteBuffer.flip(); target.scheduleOutboundData(myWriteBuffer); } else { eventCallback(b, EM_CONNECTION_READ, myReadBuffer); } } else { eventCallback(b, EM_CONNECTION_READ, myReadBuffer); } } } catch (IOException e) { UnboundConnections.add(b); } } }
void removeUnboundConnections() { ListIterator<Long> iter = UnboundConnections.listIterator(0); while (iter.hasNext()) { long b = iter.next(); EventableChannel ec = Connections.remove(b); if (ec != null) { eventCallback(b, EM_CONNECTION_UNBOUND, null); ec.close(); EventableSocketChannel sc = (EventableSocketChannel) ec; if (sc != null && sc.isAttached()) DetachedConnections.add(sc); } } UnboundConnections.clear(); }
void runTimers() { long now = new Date().getTime(); while (!Timers.isEmpty()) { long k = Timers.firstKey(); if (k > now) break; ArrayList<Long> callbacks = Timers.get(k); Timers.remove(k); // Fire all timers at this timestamp ListIterator<Long> iter = callbacks.listIterator(0); while (iter.hasNext()) { eventCallback(0, EM_TIMER_FIRED, null, iter.next().longValue()); } } }
/** * Checks for the next item. * * @return result of check * @throws IOException I/O exception */ public boolean more() throws IOException { if (cache == null) { out.write(4); send(id); cache = new ArrayList<byte[]>(); final ByteArrayOutputStream os = new ByteArrayOutputStream(); while (in.read() > 0) { receive(in, os); cache.add(os.toByteArray()); os.reset(); } if (!ok()) throw new IOException(receive()); pos = 0; } if (pos < cache.size()) return true; cache = null; return false; }
public SocketChannel detachChannel(long sig) { EventableSocketChannel ec = (EventableSocketChannel) Connections.get(sig); if (ec != null) { UnboundConnections.add(sig); return ec.getChannel(); } else { return null; } }
private static PermissionInfo[] getPermissionInfos(URL resource, Framework framework) { if (resource == null) return null; PermissionInfo[] info = EMPTY_PERM_INFO; DataInputStream in = null; try { in = new DataInputStream(resource.openStream()); ArrayList permissions = new ArrayList(); BufferedReader reader; try { reader = new BufferedReader(new InputStreamReader(in, "UTF8")); // $NON-NLS-1$ } catch (UnsupportedEncodingException e) { reader = new BufferedReader(new InputStreamReader(in)); } while (true) { String line = reader.readLine(); if (line == null) /* EOF */ break; line = line.trim(); if ((line.length() == 0) || line.startsWith("#") || line.startsWith("//")) /* comments */ // $NON-NLS-1$ //$NON-NLS-2$ continue; try { permissions.add(new PermissionInfo(line)); } catch (IllegalArgumentException iae) { /* incorrectly encoded permission */ if (framework != null) framework.publishFrameworkEvent(FrameworkEvent.ERROR, framework.getBundle(0), iae); } } int size = permissions.size(); if (size > 0) info = (PermissionInfo[]) permissions.toArray(new PermissionInfo[size]); } catch (IOException e) { // do nothing } finally { try { if (in != null) in.close(); } catch (IOException ee) { // do nothing } } return info; }
private void invokeLater(Runnable task) { synchronized (taskWorkerLock) { if (isRunning() && mainThread != Thread.currentThread()) { tasks.add(task); taskWorkerLock.notifyAll(); } else { // if !running or isEDTThread, do it right away task.run(); } } }
void removeUnboundConnections() { if (UnboundConnections.size() == 0) { return; } ArrayList<Long> currentUnboundConnections = UnboundConnections; // fix concurrent modification exception UnboundConnections = new ArrayList<Long>(); for (long b : currentUnboundConnections) { EventableChannel ec = Connections.remove(b); if (ec != null) { if (ProxyConnections != null) { ProxyConnections.remove(b); } eventCallback(b, EM_CONNECTION_UNBOUND, null); ec.close(); EventableSocketChannel sc = (EventableSocketChannel) ec; if (sc != null && sc.isAttached()) DetachedConnections.add(sc); } } }
/** * Parse type variables for generics * * @param variables * @return */ protected static TypeVar[] ParseTypeVariables(TypeVariable[] variables, ParamTag[] tags) { TypeVar[] vars = null; if (variables != null && variables.length > 0) { ArrayList<TypeVar> varsList = new ArrayList<TypeVar>(); for (TypeVariable variable : variables) { TypeVar var = new TypeVar(); var.name = variable.typeName(); Type[] bounds = variable.bounds(); if (bounds != null && bounds.length > 0) { ArrayList<String> list = new ArrayList<String>(); for (Type bound : bounds) { list.add(bound.qualifiedTypeName()); } var.bounds = list.toArray(new String[] {}); } for (ParamTag tag : tags) if (tag.parameterName().equals(var.name)) var.comment = tag.parameterComment(); varsList.add(var); } vars = varsList.toArray(new TypeVar[] {}); } return vars; }
private boolean invokeMethod(String line, PrintWriter out, Method method, String[] fields) throws IllegalAccessException, InvocationTargetException { ArrayList<Object> methodArguments = new ArrayList<Object>(); Class<?>[] parameterTypes = method.getParameterTypes(); if (parameterTypes.length == 2 && parameterTypes[0] == PrintWriter.class && parameterTypes[1] == String.class) { // FIXME: there must be a better way to say "I want to parse the line myself." methodArguments.add(out); methodArguments.add(line); } else { int nextField = 1; for (Class<?> parameterType : parameterTypes) { if (parameterType == PrintWriter.class) { methodArguments.add(out); } else if (parameterType == String.class) { methodArguments.add(fields[nextField++]); } // FIXME: support other common types. "int" seems a likely first candidate. } } method.invoke(handler, methodArguments.toArray()); return true; }
public long attachChannel(SocketChannel sc, boolean watch_mode) { long b = createBinding(); EventableSocketChannel ec = new EventableSocketChannel(sc, b, mySelector); ec.setAttached(); if (watch_mode) ec.setWatchOnly(); Connections.put(b, ec); NewConnections.add(b); return b; }
public void run() { if (DEBUG) System.err.println("MainThread.run(): " + Thread.currentThread().getName()); synchronized (taskWorkerLock) { isRunning = true; taskWorkerLock.notifyAll(); } while (!shouldStop) { try { // wait for something todo .. synchronized (taskWorkerLock) { while (!shouldStop && tasks.size() == 0) { try { taskWorkerLock.wait(); } catch (InterruptedException e) { e.printStackTrace(); } } // take over the tasks .. if (!shouldStop && tasks.size() > 0) { Runnable task = (Runnable) tasks.remove(0); task.run(); // FIXME: could be run outside of lock } taskWorkerLock.notifyAll(); } } catch (Throwable t) { // handle errors .. t.printStackTrace(); } finally { // epilog - unlock locked stuff } } if (DEBUG) System.err.println("MainThread.run(): " + Thread.currentThread().getName() + " fin"); synchronized (taskWorkerLock) { isRunning = false; isExit = true; taskWorkerLock.notifyAll(); } }