package app.fedilab.fedilabtube.client; /* Copyright 2020 Thomas Schneider * * This file is a part of TubeLab * * This program 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 3 of the * License, or (at your option) any later version. * * TubeLab 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 TubeLab; if not, * see . */ import android.content.Context; import android.content.SharedPreferences; import android.os.Build; import android.text.Html; import android.text.SpannableString; import net.gotev.uploadservice.MultipartUploadRequest; import net.gotev.uploadservice.ServerResponse; import net.gotev.uploadservice.UploadInfo; import net.gotev.uploadservice.UploadNotificationConfig; import net.gotev.uploadservice.UploadStatusDelegate; import org.apache.poi.util.IOUtils; import java.io.File; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; import java.net.Authenticator; import java.net.HttpURLConnection; import java.net.InetSocketAddress; import java.net.MalformedURLException; import java.net.PasswordAuthentication; import java.net.Proxy; import java.net.URL; import java.nio.charset.StandardCharsets; import java.security.KeyManagementException; import java.security.NoSuchAlgorithmException; import java.util.HashMap; import java.util.Iterator; import java.util.LinkedHashMap; import java.util.List; import java.util.Map; import java.util.Scanner; import java.util.regex.Matcher; import java.util.regex.Pattern; import javax.net.ssl.HttpsURLConnection; import app.fedilab.fedilabtube.R; import app.fedilab.fedilabtube.client.entities.Error; import app.fedilab.fedilabtube.helper.FileNameCleaner; import app.fedilab.fedilabtube.helper.Helper; import app.fedilab.fedilabtube.interfaces.OnDownloadInterface; @SuppressWarnings("unused") public class HttpsConnection { private HttpsURLConnection httpsURLConnection; private String since_id, max_id; private Context context; private int CHUNK_SIZE = 4096; private SharedPreferences sharedpreferences; private Proxy proxy; public HttpsConnection(Context context) { this.context = context; sharedpreferences = context.getSharedPreferences(Helper.APP_PREFS, Context.MODE_PRIVATE); boolean proxyEnabled = sharedpreferences.getBoolean(Helper.SET_PROXY_ENABLED, false); int type = sharedpreferences.getInt(Helper.SET_PROXY_TYPE, 0); proxy = null; if (proxyEnabled) { try { String host = sharedpreferences.getString(Helper.SET_PROXY_HOST, "127.0.0.1"); int port = sharedpreferences.getInt(Helper.SET_PROXY_PORT, 8118); if (type == 0) proxy = new Proxy(Proxy.Type.HTTP, new InetSocketAddress(host, port)); else proxy = new Proxy(Proxy.Type.SOCKS, new InetSocketAddress(host, port)); final String login = sharedpreferences.getString(Helper.SET_PROXY_LOGIN, null); final String pwd = sharedpreferences.getString(Helper.SET_PROXY_PASSWORD, null); if (login != null) { Authenticator authenticator = new Authenticator() { public PasswordAuthentication getPasswordAuthentication() { assert pwd != null; return (new PasswordAuthentication(login, pwd.toCharArray())); } }; Authenticator.setDefault(authenticator); } } catch (Exception e) { proxy = null; } } } /** * Get calls * * @param urlConnection String url * @param timeout int timeout * @param paramaters HashMap paramaters * @param token String token * @return String * @throws IOException IOException * @throws NoSuchAlgorithmException NoSuchAlgorithmException * @throws KeyManagementException KeyManagementException * @throws HttpsConnectionException HttpsConnectionException */ public String get(String urlConnection, int timeout, HashMap paramaters, String token) throws IOException, NoSuchAlgorithmException, KeyManagementException, HttpsConnectionException { Map params = new LinkedHashMap<>(); if (paramaters != null) { Iterator> it = paramaters.entrySet().iterator(); while (it.hasNext()) { Map.Entry pair = it.next(); params.put(pair.getKey(), pair.getValue()); it.remove(); } } StringBuilder postData = new StringBuilder(); URL url; if (params.size() > 0) { for (Map.Entry param : params.entrySet()) { if (postData.length() != 0) postData.append('&'); postData.append(param.getKey()); postData.append('='); postData.append(param.getValue()); } url = new URL(urlConnection + "?" + postData); } else { url = new URL(urlConnection); } if (proxy != null) httpsURLConnection = (HttpsURLConnection) url.openConnection(proxy); else httpsURLConnection = (HttpsURLConnection) url.openConnection(); httpsURLConnection.setConnectTimeout(timeout * 1000); httpsURLConnection.setRequestProperty("http.keepAlive", "false"); httpsURLConnection.setRequestProperty("Content-Type", "application/json"); httpsURLConnection.setRequestProperty("Accept", "application/json"); httpsURLConnection.setUseCaches(true); httpsURLConnection.setDefaultUseCaches(true); httpsURLConnection.setSSLSocketFactory(new TLSSocketFactory()); if (token != null && !token.startsWith("Basic ")) httpsURLConnection.setRequestProperty("Authorization", "Bearer " + token); else if (token != null && token.startsWith("Basic ")) httpsURLConnection.setRequestProperty("Authorization", token); httpsURLConnection.setRequestMethod("GET"); String response; if (httpsURLConnection.getResponseCode() >= 200 && httpsURLConnection.getResponseCode() < 400) { response = converToString(httpsURLConnection.getInputStream()); } else { String error = null; if (httpsURLConnection.getErrorStream() != null) { InputStream stream = httpsURLConnection.getErrorStream(); if (stream == null) { stream = httpsURLConnection.getInputStream(); } try (Scanner scanner = new Scanner(stream)) { scanner.useDelimiter("\\Z"); if (scanner.hasNext()) { error = scanner.next(); } } catch (Exception e) { e.printStackTrace(); } } int responseCode = httpsURLConnection.getResponseCode(); try { httpsURLConnection.getInputStream().close(); } catch (Exception ignored) { } throw new HttpsConnectionException(responseCode, error); } getSinceMaxId(); httpsURLConnection.getInputStream().close(); return response; } public String get(String urlConnection) throws IOException, NoSuchAlgorithmException, KeyManagementException, HttpsConnectionException { URL url = new URL(urlConnection); if (proxy != null) httpsURLConnection = (HttpsURLConnection) url.openConnection(proxy); else httpsURLConnection = (HttpsURLConnection) url.openConnection(); httpsURLConnection.setConnectTimeout(30 * 1000); httpsURLConnection.setRequestProperty("http.keepAlive", "false"); httpsURLConnection.setRequestProperty("Content-Type", "application/json"); httpsURLConnection.setRequestProperty("Accept", "application/json"); httpsURLConnection.setSSLSocketFactory(new TLSSocketFactory()); httpsURLConnection.setRequestMethod("GET"); httpsURLConnection.setDefaultUseCaches(true); httpsURLConnection.setUseCaches(true); String response; if (httpsURLConnection.getResponseCode() >= 200 && httpsURLConnection.getResponseCode() < 400) { getSinceMaxId(); response = converToString(httpsURLConnection.getInputStream()); } else { String error = null; if (httpsURLConnection.getErrorStream() != null) { InputStream stream = httpsURLConnection.getErrorStream(); if (stream == null) { stream = httpsURLConnection.getInputStream(); } try (Scanner scanner = new Scanner(stream)) { scanner.useDelimiter("\\Z"); if (scanner.hasNext()) { error = scanner.next(); } } catch (Exception e) { e.printStackTrace(); } } int responseCode = httpsURLConnection.getResponseCode(); try { httpsURLConnection.getInputStream().close(); } catch (Exception ignored) { } throw new HttpsConnectionException(responseCode, error); } getSinceMaxId(); httpsURLConnection.getInputStream().close(); return response; } public String post(String urlConnection, int timeout, HashMap paramaters, String token) throws IOException, NoSuchAlgorithmException, KeyManagementException, HttpsConnectionException { URL url = new URL(urlConnection); Map params = new LinkedHashMap<>(); if (paramaters != null) { Iterator> it = paramaters.entrySet().iterator(); while (it.hasNext()) { Map.Entry pair = it.next(); params.put(pair.getKey(), pair.getValue()); it.remove(); } } StringBuilder postData = new StringBuilder(); for (Map.Entry param : params.entrySet()) { if (postData.length() != 0) postData.append('&'); postData.append(param.getKey()); postData.append('='); postData.append(param.getValue()); } byte[] postDataBytes = postData.toString().getBytes(StandardCharsets.UTF_8); if (proxy != null) httpsURLConnection = (HttpsURLConnection) url.openConnection(proxy); else httpsURLConnection = (HttpsURLConnection) url.openConnection(); httpsURLConnection.setConnectTimeout(timeout * 1000); httpsURLConnection.setDoOutput(true); httpsURLConnection.setSSLSocketFactory(new TLSSocketFactory()); httpsURLConnection.setRequestMethod("POST"); if (token != null && !token.startsWith("Basic ")) httpsURLConnection.setRequestProperty("Authorization", "Bearer " + token); else if (token != null && token.startsWith("Basic ")) httpsURLConnection.setRequestProperty("Authorization", token); httpsURLConnection.setRequestProperty("Content-Length", String.valueOf(postDataBytes.length)); httpsURLConnection.getOutputStream().write(postDataBytes); String response; if (httpsURLConnection.getResponseCode() >= 200 && httpsURLConnection.getResponseCode() < 400) { getSinceMaxId(); response = converToString(httpsURLConnection.getInputStream()); } else { String error = null; if (httpsURLConnection.getErrorStream() != null) { InputStream stream = httpsURLConnection.getErrorStream(); if (stream == null) { stream = httpsURLConnection.getInputStream(); } try (Scanner scanner = new Scanner(stream)) { scanner.useDelimiter("\\Z"); if (scanner.hasNext()) { error = scanner.next(); } } catch (Exception e) { e.printStackTrace(); } } int responseCode = httpsURLConnection.getResponseCode(); try { httpsURLConnection.getInputStream().close(); } catch (Exception ignored) { } throw new HttpsConnectionException(responseCode, error); } getSinceMaxId(); httpsURLConnection.getInputStream().close(); return response; } /*** * Download method which works for http and https connections * @param downloadUrl String download url * @param listener OnDownloadInterface, listener which manages progress */ public void download(final String downloadUrl, final OnDownloadInterface listener) { new Thread(() -> { URL url; HttpsURLConnection httpsURLConnection; try { url = new URL(downloadUrl); if (proxy != null) httpsURLConnection = (HttpsURLConnection) url.openConnection(proxy); else httpsURLConnection = (HttpsURLConnection) url.openConnection(); int responseCode = httpsURLConnection.getResponseCode(); // always check HTTP response code first if (responseCode == HttpURLConnection.HTTP_OK) { String fileName = ""; String disposition = httpsURLConnection.getHeaderField("Content-Disposition"); if (disposition != null) { // extracts file name from header field int index = disposition.indexOf("filename="); if (index > 0) { fileName = disposition.substring(index + 10, disposition.length() - 1); } } else { // extracts file name from URL fileName = downloadUrl.substring(downloadUrl.lastIndexOf("/") + 1 ); } fileName = FileNameCleaner.cleanFileName(fileName); // opens input stream from the HTTP connection InputStream inputStream = httpsURLConnection.getInputStream(); File saveDir = context.getCacheDir(); final String saveFilePath = saveDir + File.separator + fileName; // opens an output stream to save into file FileOutputStream outputStream = new FileOutputStream(saveFilePath); int bytesRead; byte[] buffer = new byte[CHUNK_SIZE]; while ((bytesRead = inputStream.read(buffer)) != -1) { outputStream.write(buffer, 0, bytesRead); } outputStream.close(); inputStream.close(); } else { final Error error = new Error(); error.setError(String.valueOf(responseCode)); } } catch (IOException e) { Error error = new Error(); error.setError(context.getString(R.string.toast_error)); } }).start(); } public InputStream getPicture(final String downloadUrl) { URL url; try { url = new URL(downloadUrl); } catch (MalformedURLException e) { return null; } try { if (proxy != null) httpsURLConnection = (HttpsURLConnection) url.openConnection(proxy); else httpsURLConnection = (HttpsURLConnection) url.openConnection(); httpsURLConnection.setSSLSocketFactory(new TLSSocketFactory()); int responseCode = httpsURLConnection.getResponseCode(); // always check HTTP response code first if (responseCode == HttpURLConnection.HTTP_OK) { // opens input stream from the HTTP connection return httpsURLConnection.getInputStream(); } httpsURLConnection.getInputStream().close(); } catch (IOException | NoSuchAlgorithmException | KeyManagementException ignored) { } if (httpsURLConnection != null) try { httpsURLConnection.getInputStream().close(); } catch (Exception ignored) { } return null; } private void uploadMedia(String urlConnection, InputStream avatar, InputStream header, String filename) { UploadNotificationConfig uploadConfig = new UploadNotificationConfig(); uploadConfig.getCompleted().autoClear = true; final File file = new File(context.getCacheDir() + "/" + filename); OutputStream outputStream; try { outputStream = new FileOutputStream(file); if (avatar != null) { IOUtils.copy(avatar, outputStream); } else { IOUtils.copy(header, outputStream); } } catch (IOException e) { e.printStackTrace(); } try { String token = sharedpreferences.getString(Helper.PREF_KEY_OAUTH_TOKEN, null); MultipartUploadRequest m = new MultipartUploadRequest(context, urlConnection) .setMethod("PATCH"); if (avatar != null) { m.addFileToUpload(file.getPath(), "avatar"); } else { m.addFileToUpload(file.getPath(), "header"); } m.addParameter("name", filename) .addHeader("Authorization", "Bearer " + token) .setNotificationConfig(uploadConfig) .setDelegate(new UploadStatusDelegate() { @Override public void onProgress(Context context, UploadInfo uploadInfo) { // your code here } @Override public void onError(Context context, UploadInfo uploadInfo, ServerResponse serverResponse, Exception exception) { //noinspection ResultOfMethodCallIgnored file.delete(); } @Override public void onCompleted(Context context, UploadInfo uploadInfo, ServerResponse serverResponse) { //noinspection ResultOfMethodCallIgnored file.delete(); } @Override public void onCancelled(Context context, UploadInfo uploadInfo) { //noinspection ResultOfMethodCallIgnored file.delete(); } }) .startUpload(); } catch (MalformedURLException | FileNotFoundException e) { e.printStackTrace(); } } @SuppressWarnings("SameParameterValue") public String patch(String urlConnection, int timeout, HashMap paramaters, InputStream avatar, String avatarName, InputStream header, String headerName, String token) throws IOException, NoSuchAlgorithmException, KeyManagementException, HttpsConnectionException { URL url = new URL(urlConnection); Map params = new LinkedHashMap<>(); if (paramaters != null) { Iterator> it = paramaters.entrySet().iterator(); while (it.hasNext()) { Map.Entry pair = it.next(); params.put(pair.getKey(), pair.getValue()); it.remove(); } } StringBuilder postData = new StringBuilder(); for (Map.Entry param : params.entrySet()) { if (postData.length() != 0) postData.append('&'); postData.append(param.getKey()); postData.append('='); postData.append(param.getValue()); } byte[] postDataBytes = (postData.toString()).getBytes(StandardCharsets.UTF_8); if (proxy != null) httpsURLConnection = (HttpsURLConnection) url.openConnection(proxy); else httpsURLConnection = (HttpsURLConnection) url.openConnection(); httpsURLConnection.setConnectTimeout(timeout * 1000); httpsURLConnection.setSSLSocketFactory(new TLSSocketFactory()); httpsURLConnection.setRequestMethod("PATCH"); if (token != null && !token.startsWith("Basic ")) httpsURLConnection.setRequestProperty("Authorization", "Bearer " + token); else if (token != null && token.startsWith("Basic ")) httpsURLConnection.setRequestProperty("Authorization", token); httpsURLConnection.setRequestProperty("Content-Type", "application/x-www-form-urlencoded"); httpsURLConnection.setRequestProperty("Content-Length", String.valueOf(postDataBytes.length)); httpsURLConnection.setDoOutput(true); String response; OutputStream outputStream = httpsURLConnection.getOutputStream(); outputStream.write(postDataBytes); if (avatar != null) { uploadMedia(urlConnection, avatar, null, avatarName); } if (header != null) { uploadMedia(urlConnection, null, header, headerName); } if (httpsURLConnection.getResponseCode() >= 200 && httpsURLConnection.getResponseCode() < 400) { response = converToString(httpsURLConnection.getInputStream()); } else { String error = null; if (httpsURLConnection.getErrorStream() != null) { InputStream stream = httpsURLConnection.getErrorStream(); if (stream == null) { stream = httpsURLConnection.getInputStream(); } try (Scanner scanner = new Scanner(stream)) { scanner.useDelimiter("\\Z"); if (scanner.hasNext()) { error = scanner.next(); } } catch (Exception e) { e.printStackTrace(); } } int responseCode = httpsURLConnection.getResponseCode(); try { httpsURLConnection.getInputStream().close(); } catch (Exception ignored) { } try { httpsURLConnection.getInputStream().close(); } catch (Exception ignored) { } throw new HttpsConnectionException(responseCode, error); } httpsURLConnection.getInputStream().close(); return response; } public String put(String urlConnection, int timeout, HashMap paramaters, String token) throws IOException, NoSuchAlgorithmException, KeyManagementException, HttpsConnectionException { URL url = new URL(urlConnection); Map params = new LinkedHashMap<>(); if (paramaters != null) { Iterator> it = paramaters.entrySet().iterator(); while (it.hasNext()) { Map.Entry pair = it.next(); params.put(pair.getKey(), pair.getValue()); it.remove(); } } StringBuilder postData = new StringBuilder(); for (Map.Entry param : params.entrySet()) { if (postData.length() != 0) postData.append('&'); postData.append(param.getKey()); postData.append('='); postData.append(param.getValue()); } byte[] postDataBytes = postData.toString().getBytes(StandardCharsets.UTF_8); if (proxy != null) httpsURLConnection = (HttpsURLConnection) url.openConnection(proxy); else httpsURLConnection = (HttpsURLConnection) url.openConnection(); httpsURLConnection.setConnectTimeout(timeout * 1000); httpsURLConnection.setSSLSocketFactory(new TLSSocketFactory()); if (token != null && !token.startsWith("Basic ")) httpsURLConnection.setRequestProperty("Authorization", "Bearer " + token); else if (token != null && token.startsWith("Basic ")) httpsURLConnection.setRequestProperty("Authorization", token); httpsURLConnection.setRequestProperty("Content-Length", String.valueOf(postDataBytes.length)); httpsURLConnection.setRequestMethod("PUT"); httpsURLConnection.setDoInput(true); httpsURLConnection.setDoOutput(true); httpsURLConnection.getOutputStream().write(postDataBytes); String response; if (httpsURLConnection.getResponseCode() >= 200 && httpsURLConnection.getResponseCode() < 400) { getSinceMaxId(); response = converToString(httpsURLConnection.getInputStream()); } else { String error = null; if (httpsURLConnection.getErrorStream() != null) { InputStream stream = httpsURLConnection.getErrorStream(); if (stream == null) { stream = httpsURLConnection.getInputStream(); } try (Scanner scanner = new Scanner(stream)) { scanner.useDelimiter("\\Z"); if (scanner.hasNext()) { error = scanner.next(); } } catch (Exception e) { e.printStackTrace(); } } int responseCode = httpsURLConnection.getResponseCode(); try { httpsURLConnection.getInputStream().close(); } catch (Exception ignored) { } throw new HttpsConnectionException(responseCode, error); } getSinceMaxId(); httpsURLConnection.getInputStream().close(); return response; } public void delete(String urlConnection, int timeout, HashMap paramaters, String token) throws IOException, NoSuchAlgorithmException, KeyManagementException, HttpsConnectionException { URL url = new URL(urlConnection); Map params = new LinkedHashMap<>(); if (paramaters != null) { Iterator> it = paramaters.entrySet().iterator(); while (it.hasNext()) { Map.Entry pair = it.next(); params.put(pair.getKey(), pair.getValue()); it.remove(); } } StringBuilder postData = new StringBuilder(); for (Map.Entry param : params.entrySet()) { if (postData.length() != 0) postData.append('&'); postData.append(param.getKey()); postData.append('='); postData.append(param.getValue()); } byte[] postDataBytes = postData.toString().getBytes(StandardCharsets.UTF_8); if (proxy != null) httpsURLConnection = (HttpsURLConnection) url.openConnection(proxy); else httpsURLConnection = (HttpsURLConnection) url.openConnection(); httpsURLConnection.setSSLSocketFactory(new TLSSocketFactory()); if (token != null && !token.startsWith("Basic ")) httpsURLConnection.setRequestProperty("Authorization", "Bearer " + token); else if (token != null && token.startsWith("Basic ")) httpsURLConnection.setRequestProperty("Authorization", token); httpsURLConnection.setRequestProperty("Content-Type", "application/x-www-form-urlencoded"); httpsURLConnection.setRequestMethod("DELETE"); httpsURLConnection.setConnectTimeout(timeout * 1000); httpsURLConnection.setRequestProperty("Content-Length", String.valueOf(postDataBytes.length)); httpsURLConnection.getOutputStream().write(postDataBytes); if (httpsURLConnection.getResponseCode() >= 200 && httpsURLConnection.getResponseCode() < 400) { getSinceMaxId(); httpsURLConnection.getInputStream().close(); httpsURLConnection.getResponseCode(); } else { String error = null; if (httpsURLConnection.getErrorStream() != null) { InputStream stream = httpsURLConnection.getErrorStream(); if (stream == null) { stream = httpsURLConnection.getInputStream(); } try (Scanner scanner = new Scanner(stream)) { scanner.useDelimiter("\\Z"); if (scanner.hasNext()) { error = scanner.next(); } } catch (Exception e) { e.printStackTrace(); } } int responseCode = httpsURLConnection.getResponseCode(); try { httpsURLConnection.getInputStream().close(); } catch (Exception ignored) { } throw new HttpsConnectionException(responseCode, error); } } public String getSince_id() { return since_id; } public String getMax_id() { return max_id; } private void getSinceMaxId() { if (httpsURLConnection == null) return; Map> map = httpsURLConnection.getHeaderFields(); for (Map.Entry> entry : map.entrySet()) { if (entry.toString().startsWith("Link") || entry.toString().startsWith("link")) { Pattern patternMaxId = Pattern.compile("max_id=([0-9a-zA-Z]+).*"); Matcher matcherMaxId = patternMaxId.matcher(entry.toString()); if (matcherMaxId.find()) { max_id = matcherMaxId.group(1); } if (entry.toString().startsWith("Link")) { Pattern patternSinceId = Pattern.compile("since_id=([0-9a-zA-Z]+).*"); Matcher matcherSinceId = patternSinceId.matcher(entry.toString()); if (matcherSinceId.find()) { since_id = matcherSinceId.group(1); } } } else if (entry.toString().startsWith("Min-Id") || entry.toString().startsWith("min-id")) { Pattern patternMaxId = Pattern.compile("min-id=\\[([0-9a-zA-Z]+).*]"); Matcher matcherMaxId = patternMaxId.matcher(entry.toString()); if (matcherMaxId.find()) { max_id = matcherMaxId.group(1); } } } } private String converToString(InputStream inputStream) { Scanner s = new Scanner(inputStream).useDelimiter("\\A"); return s.hasNext() ? s.next() : ""; } int getActionCode() { try { return httpsURLConnection.getResponseCode(); } catch (IOException e) { return -1; } } public class HttpsConnectionException extends Exception { private int statusCode; private String message; HttpsConnectionException(int statusCode, String message) { this.statusCode = statusCode; SpannableString spannableString; if (message != null) { if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) spannableString = new SpannableString(Html.fromHtml(message, Html.FROM_HTML_MODE_LEGACY)); else spannableString = new SpannableString(Html.fromHtml(message)); } else { spannableString = new SpannableString(context.getString(R.string.toast_error)); } this.message = spannableString.toString(); } public int getStatusCode() { return statusCode; } @Override public String getMessage() { return message; } } }