private static void maybeClose(InputStream is) { CloseableUtil.maybeClose(is, LOGGER); } }
private static void writeIntegers(File target, Set<Integer> integers) { if (target == null) { LOGGER.log(Level.WARNING, "Could not write integers to null-path."); return; } DataOutputStream out = null; try { out = new DataOutputStream(new FileOutputStream(target)); for (int i : integers) { out.writeInt(i); } } catch (IOException e) { LOGGER.log(Level.SEVERE, "Could not write integers to file.", e); } finally { CloseableUtil.maybeClose(out, LOGGER); } }
private static Long readLong(File target) { if (target == null) { LOGGER.log(Level.WARNING, "Could not read long from null-path."); return null; } Long l; DataInputStream in = null; try { in = new DataInputStream(new FileInputStream(target)); l = in.readLong(); } catch (FileNotFoundException e) { l = null; } catch (IOException e) { LOGGER.log(Level.SEVERE, "Could not read long from file.", e); return null; } finally { CloseableUtil.maybeClose(in, LOGGER); } return l; }
private static void writeLong(File target, long i) { if (target == null) { LOGGER.log(Level.WARNING, "Could not write long to null-path."); return; } try { FileHierarchy.createFile(target); } catch (IOException e) { LOGGER.log(Level.SEVERE, "Could not create file.", e); return; } DataOutputStream out = null; try { out = new DataOutputStream(new FileOutputStream(target)); out.writeLong(i); } catch (IOException e) { LOGGER.log(Level.SEVERE, "Could not write longs to file.", e); } finally { CloseableUtil.maybeClose(out, LOGGER); } }
private static byte[] readBytes(File target) { if (target == null) { LOGGER.log(Level.WARNING, "Could not read bytes from null-path."); return null; } byte[] b = null; DataInputStream in = null; try { in = new DataInputStream(new FileInputStream(target)); b = new byte[(int) target.length()]; in.read(b); } catch (FileNotFoundException e) { b = null; } catch (IOException e) { LOGGER.log(Level.SEVERE, "Could not read bytes from file.", e); } finally { CloseableUtil.maybeClose(in, LOGGER); } return b; }
private static void writeBytes(File target, byte[] bytes) { if (target == null) { LOGGER.log(Level.WARNING, "Could not write bytes to null-path."); return; } // Create file try { FileHierarchy.createFile(target); } catch (IOException e) { LOGGER.log(Level.SEVERE, "Could not create file.", e); return; } DataOutputStream out = null; try { out = new DataOutputStream(new FileOutputStream(target)); out.write(bytes); } catch (IOException e) { LOGGER.log(Level.SEVERE, "Could not write bytes to file.", e); } finally { CloseableUtil.maybeClose(out, LOGGER); } }
private static Set<Integer> readIntegers(File target) { if (target == null) { LOGGER.log(Level.WARNING, "Could not read integers from null-path."); return null; } HashSet<Integer> integers = new HashSet<>(); DataInputStream in = null; try { in = new DataInputStream(new FileInputStream(target)); try { while (true) { integers.add(in.readInt()); } } catch (EOFException e) { // Reached end of the list. } } catch (FileNotFoundException e) { integers = null; } catch (IOException e) { LOGGER.log(Level.SEVERE, "Could not read integers.", e); } finally { CloseableUtil.maybeClose(in, LOGGER); } return integers; }
CloseableUtil.maybeClose(readerPipe, LOGGER); CloseableUtil.maybeClose(reader, LOGGER); CloseableUtil.maybeClose(writer, LOGGER);
@Override public void run() { while (true) { Socket socket = null; try { if (Socks5Proxy.this.serverSocket == null || Socks5Proxy.this.serverSocket.isClosed() || Thread.currentThread().isInterrupted()) { return; } // accept connection socket = Socks5Proxy.this.serverSocket.accept(); // initialize connection establishConnection(socket); } catch (SocketException e) { /* * do nothing, if caused by closing the server socket, thread will terminate in * next loop */ } catch (Exception e) { CloseableUtil.maybeClose(socket, LOGGER); } } }
CloseableUtil.maybeClose(reader, LOGGER);
@Override public Socket call() throws IOException, SmackException { // initialize socket Socket socket = new Socket(); SocketAddress socketAddress = new InetSocketAddress(streamHost.getAddress(), streamHost.getPort()); socket.connect(socketAddress); // initialize connection to SOCKS5 proxy try { establish(socket); } catch (SmackException e) { if (!socket.isClosed()) { CloseableUtil.maybeClose(socket, LOGGER); } throw e; } return socket; }
public static void processConfigFile(InputStream cfgFileStream, Collection<Exception> exceptions, ClassLoader classLoader) throws Exception { XmlPullParser parser = XmlPullParserFactory.newInstance().newPullParser(); parser.setFeature(XmlPullParser.FEATURE_PROCESS_NAMESPACES, true); parser.setInput(cfgFileStream, "UTF-8"); int eventType = parser.getEventType(); do { if (eventType == XmlPullParser.START_TAG) { if (parser.getName().equals("startupClasses")) { parseClassesToLoad(parser, false, exceptions, classLoader); } else if (parser.getName().equals("optionalStartupClasses")) { parseClassesToLoad(parser, true, exceptions, classLoader); } } eventType = parser.next(); } while (eventType != XmlPullParser.END_DOCUMENT); CloseableUtil.maybeClose(cfgFileStream, LOGGER); }
@Override protected Trust readTrust(BareJid owner, OpenPgpV4Fingerprint fingerprint) throws IOException { File file = getTrustPath(owner, fingerprint); BufferedReader reader = null; try { InputStream inputStream = FileUtils.prepareFileInputStream(file); InputStreamReader isr = new InputStreamReader(inputStream, Util.UTF8); reader = new BufferedReader(isr); Trust trust = null; String line; int lineNr = 0; while ((line = reader.readLine()) != null) { lineNr++; try { trust = Trust.valueOf(line); break; } catch (IllegalArgumentException e) { LOGGER.log(Level.WARNING, "Skipping invalid trust record in line " + lineNr + " \"" + line + "\" of file " + file.getAbsolutePath()); } } return trust != null ? trust : Trust.undecided; } catch (IOException e) { if (e instanceof FileNotFoundException) { return Trust.undecided; } throw e; } finally { CloseableUtil.maybeClose(reader, LOGGER); } }
static void writeFingerprintsAndDates(Map<OpenPgpV4Fingerprint, Date> data, File destination) throws IOException { if (data == null || data.isEmpty()) { FileUtils.maybeDeleteFileOrThrow(destination); return; } FileUtils.maybeCreateFileWithParentDirectories(destination); BufferedWriter writer = null; try { OutputStream outputStream = FileUtils.prepareFileOutputStream(destination); OutputStreamWriter osw = new OutputStreamWriter(outputStream, Util.UTF8); writer = new BufferedWriter(osw); for (OpenPgpV4Fingerprint fingerprint : data.keySet()) { Date date = data.get(fingerprint); String line = fingerprint.toString() + " " + (date != null ? XmppDateTime.formatXEP0082Date(date) : XmppDateTime.formatXEP0082Date(new Date())); writer.write(line); writer.newLine(); } } finally { CloseableUtil.maybeClose(writer, LOGGER); } }
@Override protected void writeTrust(BareJid owner, OpenPgpV4Fingerprint fingerprint, Trust trust) throws IOException { File file = getTrustPath(owner, fingerprint); if (trust == null || trust == Trust.undecided) { FileUtils.maybeDeleteFileOrThrow(file); } FileUtils.maybeCreateFileWithParentDirectories(file); BufferedWriter writer = null; try { OutputStream outputStream = FileUtils.prepareFileOutputStream(file); OutputStreamWriter osw = new OutputStreamWriter(outputStream, Util.UTF8); writer = new BufferedWriter(osw); writer.write(trust.toString()); } finally { CloseableUtil.maybeClose(writer, LOGGER); } }
@Override public void finish(SSLSocket sslSocket) throws CertificateException { if (VERIFIER.verify(sslSocket)) { // DANE verification was the only requirement according to the TLSA RR. We can return here. return; } // DANE verification was successful, but according to the TLSA RR we also must perform PKIX validation. if (expectingTrustManager.hasException()) { // PKIX validation has failed. Throw an exception but close the socket first. CloseableUtil.maybeClose(sslSocket, LOGGER); throw expectingTrustManager.getException(); } }
CloseableUtil.maybeClose(providerStream, LOGGER);
@Override public void writePublicKeysOf(BareJid owner, PGPPublicKeyRingCollection publicKeys) throws IOException { File file = getPublicKeyRingPath(owner); if (publicKeys == null) { FileUtils.maybeDeleteFileOrThrow(file); return; } OutputStream outputStream = null; try { outputStream = FileUtils.prepareFileOutputStream(file); publicKeys.encode(outputStream); } finally { CloseableUtil.maybeClose(outputStream, LOGGER); } }
@Override public void writeSecretKeysOf(BareJid owner, PGPSecretKeyRingCollection secretKeys) throws IOException { File file = getSecretKeyRingPath(owner); if (secretKeys == null) { FileUtils.maybeDeleteFileOrThrow(file); return; } OutputStream outputStream = null; try { outputStream = FileUtils.prepareFileOutputStream(file); secretKeys.encode(outputStream); } finally { CloseableUtil.maybeClose(outputStream, LOGGER); } }
@Override public void run() { // Create packet filter. try { outputStream = negotiateStream(fileName, fileSize, description); } catch (XMPPErrorException e) { handleXMPPException(e); return; } catch (Exception e) { setException(e); } if (outputStream == null) { return; } if (!updateStatus(Status.negotiated, Status.in_progress)) { return; } try { writeToStream(in, outputStream); } catch (IOException e) { setStatus(FileTransfer.Status.error); setException(e); } finally { CloseableUtil.maybeClose(in, LOGGER); CloseableUtil.maybeClose(outputStream, LOGGER); } updateStatus(Status.in_progress, FileTransfer.Status.complete); }