]> nmode's Git Repositories - signal-cli/blobdiff - lib/src/main/java/org/asamk/signal/manager/util/Utils.java
Update dependencies
[signal-cli] / lib / src / main / java / org / asamk / signal / manager / util / Utils.java
index 2963a9966b7c770d2086795134ac2c194fd1922c..16aa32755ff343dc4d2a47c3b01ef8843d6f9974 100644 (file)
 package org.asamk.signal.manager.util;
 
-import com.fasterxml.jackson.databind.JsonNode;
-
-import org.whispersystems.libsignal.IdentityKey;
-import org.whispersystems.libsignal.fingerprint.NumericFingerprintGenerator;
-import org.whispersystems.signalservice.api.push.SignalServiceAddress;
+import org.asamk.signal.manager.api.Pair;
+import org.signal.libsignal.protocol.IdentityKey;
+import org.signal.libsignal.protocol.fingerprint.Fingerprint;
+import org.signal.libsignal.protocol.fingerprint.NumericFingerprintGenerator;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.whispersystems.signalservice.api.NetworkResult;
+import org.whispersystems.signalservice.api.push.ServiceId;
 import org.whispersystems.signalservice.api.util.StreamDetails;
-import org.whispersystems.signalservice.api.util.UuidUtil;
 
-import java.io.BufferedInputStream;
+import java.io.ByteArrayInputStream;
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.IOException;
 import java.io.InputStream;
-import java.io.InvalidObjectException;
-import java.net.URLConnection;
-import java.nio.file.Files;
+import java.net.URLDecoder;
+import java.nio.charset.StandardCharsets;
+import java.util.HashMap;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Spliterator;
+import java.util.Spliterators;
+import java.util.function.BiFunction;
+import java.util.function.Consumer;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+import java.util.stream.StreamSupport;
 
 public class Utils {
 
-    public static String getFileMimeType(File file, String defaultMimeType) throws IOException {
-        var mime = Files.probeContentType(file.toPath());
-        if (mime == null) {
-            try (InputStream bufferedStream = new BufferedInputStream(new FileInputStream(file))) {
-                mime = URLConnection.guessContentTypeFromStream(bufferedStream);
-            }
-        }
-        if (mime == null) {
-            return defaultMimeType;
-        }
-        return mime;
+    private static final Logger logger = LoggerFactory.getLogger(Utils.class);
+
+    public static Pair<StreamDetails, Optional<String>> createStreamDetailsFromDataURI(final String dataURI) {
+        final DataURI uri = DataURI.of(dataURI);
+
+        return new Pair<>(new StreamDetails(new ByteArrayInputStream(uri.data()), uri.mediaType(), uri.data().length),
+                Optional.ofNullable(uri.parameter().get("filename")));
     }
 
-    public static StreamDetails createStreamDetailsFromFile(File file) throws IOException {
-        InputStream stream = new FileInputStream(file);
+    public static StreamDetails createStreamDetailsFromFile(final File file) throws IOException {
+        final InputStream stream = new FileInputStream(file);
         final var size = file.length();
-        final var mime = getFileMimeType(file, "application/octet-stream");
+        final var mime = MimeUtils.getFileMimeType(file).orElse(MimeUtils.OCTET_STREAM);
         return new StreamDetails(stream, mime, size);
     }
 
-    public static String computeSafetyNumber(
-            boolean isUuidCapable,
-            SignalServiceAddress ownAddress,
-            IdentityKey ownIdentityKey,
-            SignalServiceAddress theirAddress,
-            IdentityKey theirIdentityKey
-    ) {
-        int version;
-        byte[] ownId;
-        byte[] theirId;
-
-        if (isUuidCapable && ownAddress.getUuid().isPresent() && theirAddress.getUuid().isPresent()) {
-            // Version 2: UUID user
-            version = 2;
-            ownId = UuidUtil.toByteArray(ownAddress.getUuid().get());
-            theirId = UuidUtil.toByteArray(theirAddress.getUuid().get());
-        } else {
-            // Version 1: E164 user
-            version = 1;
-            if (!ownAddress.getNumber().isPresent() || !theirAddress.getNumber().isPresent()) {
-                return "INVALID ID";
-            }
-            ownId = ownAddress.getNumber().get().getBytes();
-            theirId = theirAddress.getNumber().get().getBytes();
+    public static Pair<StreamDetails, Optional<String>> createStreamDetails(final String value) throws IOException {
+        try {
+            return createStreamDetailsFromDataURI(value);
+        } catch (final IllegalArgumentException e) {
+            final File f = new File(value);
+
+            return new Pair<>(createStreamDetailsFromFile(f), Optional.of(f.getName()));
         }
+    }
+
+    public static Fingerprint computeSafetyNumberForNumber(
+            String ownNumber, IdentityKey ownIdentityKey, String theirNumber, IdentityKey theirIdentityKey
+    ) {
+        // Version 1: E164 user
+        final var version = 1;
+        final var ownId = ownNumber.getBytes(StandardCharsets.UTF_8);
+        final var theirId = theirNumber.getBytes(StandardCharsets.UTF_8);
 
-        var fingerprint = new NumericFingerprintGenerator(5200).createFor(version,
+        return getFingerprint(version, ownId, ownIdentityKey, theirId, theirIdentityKey);
+    }
+
+    public static Fingerprint computeSafetyNumberForUuid(
+            ServiceId ownServiceId, IdentityKey ownIdentityKey, ServiceId theirServiceId, IdentityKey theirIdentityKey
+    ) {
+        // Version 2: UUID user
+        final var version = 2;
+        final var ownId = ownServiceId.toByteArray();
+        final var theirId = theirServiceId.toByteArray();
+
+        return getFingerprint(version, ownId, ownIdentityKey, theirId, theirIdentityKey);
+    }
+
+    private static Fingerprint getFingerprint(
+            final int version,
+            final byte[] ownId,
+            final IdentityKey ownIdentityKey,
+            final byte[] theirId,
+            final IdentityKey theirIdentityKey
+    ) {
+        return new NumericFingerprintGenerator(5200).createFor(version,
                 ownId,
                 ownIdentityKey,
                 theirId,
                 theirIdentityKey);
-        return fingerprint.getDisplayableFingerprint().getDisplayText();
     }
 
-    public static SignalServiceAddress getSignalServiceAddressFromIdentifier(final String identifier) {
-        if (UuidUtil.isUuid(identifier)) {
-            return new SignalServiceAddress(UuidUtil.parseOrNull(identifier), null);
-        } else {
-            return new SignalServiceAddress(null, identifier);
+    public static Locale getDefaultLocale(Locale fallback) {
+        final var locale = Locale.getDefault();
+        if (locale == null) {
+            logger.debug("No default locale found, using fallback: {}", fallback);
+            return fallback;
         }
+        final var localeString = locale.getLanguage() + "-" + locale.getCountry();
+        try {
+            Locale.LanguageRange.parse(localeString);
+        } catch (IllegalArgumentException e) {
+            logger.debug("Invalid locale '{}', using fallback: {}", locale, fallback);
+            return fallback;
+        }
+
+        logger.trace("Using default locale: {} ({})", locale, localeString);
+        return locale;
+    }
+
+    public static <L, R, T> Stream<T> zip(Stream<L> leftStream, Stream<R> rightStream, BiFunction<L, R, T> combiner) {
+        Spliterator<L> lefts = leftStream.spliterator();
+        Spliterator<R> rights = rightStream.spliterator();
+        return StreamSupport.stream(new Spliterators.AbstractSpliterator<>(Long.min(lefts.estimateSize(),
+                rights.estimateSize()), lefts.characteristics() & rights.characteristics()) {
+            @Override
+            public boolean tryAdvance(Consumer<? super T> action) {
+                return lefts.tryAdvance(left -> rights.tryAdvance(right -> action.accept(combiner.apply(left, right))));
+            }
+        }, leftStream.isParallel() || rightStream.isParallel());
+    }
+
+    public static <OK, NK, V> Map<NK, V> mapKeys(Map<OK, V> map, Function<OK, NK> keyMapper) {
+        return map.entrySet().stream().collect(Collectors.toMap(e -> keyMapper.apply(e.getKey()), Map.Entry::getValue));
     }
 
-    public static JsonNode getNotNullNode(JsonNode parent, String name) throws InvalidObjectException {
-        var node = parent.get(name);
-        if (node == null || node.isNull()) {
-            throw new InvalidObjectException(String.format("Incorrect file format: expected parameter %s not found ",
-                    name));
+    public static Map<String, String> getQueryMap(String query) {
+        var params = query.split("&");
+        var map = new HashMap<String, String>();
+        for (var param : params) {
+            final var paramParts = param.split("=");
+            var name = URLDecoder.decode(paramParts[0], StandardCharsets.UTF_8);
+            var value = paramParts.length == 1 ? null : URLDecoder.decode(paramParts[1], StandardCharsets.UTF_8);
+            map.put(name, value);
         }
+        return map;
+    }
 
-        return node;
+    public static <T> T handleResponseException(final NetworkResult<T> response) throws IOException {
+        final var throwableOptional = response.getCause();
+        if (throwableOptional != null) {
+            if (throwableOptional instanceof IOException ioException) {
+                throw ioException;
+            } else {
+                throw new IOException(throwableOptional);
+            }
+        }
+        return response.successOrThrow();
     }
 }