*/
package org.asamk.signal.manager;
-import com.fasterxml.jackson.databind.ObjectMapper;
-
import org.asamk.signal.manager.groups.GroupId;
import org.asamk.signal.manager.groups.GroupIdV1;
import org.asamk.signal.manager.groups.GroupIdV2;
import org.asamk.signal.manager.util.AttachmentUtils;
import org.asamk.signal.manager.util.IOUtils;
import org.asamk.signal.manager.util.KeyUtils;
+import org.asamk.signal.manager.util.ProfileUtils;
+import org.asamk.signal.manager.util.StickerUtils;
import org.asamk.signal.manager.util.Utils;
import org.signal.libsignal.metadata.InvalidMetadataMessageException;
import org.signal.libsignal.metadata.InvalidMetadataVersionException;
import org.whispersystems.signalservice.api.SignalServiceMessagePipe;
import org.whispersystems.signalservice.api.SignalServiceMessageReceiver;
import org.whispersystems.signalservice.api.SignalServiceMessageSender;
-import org.whispersystems.signalservice.api.crypto.InvalidCiphertextException;
-import org.whispersystems.signalservice.api.crypto.ProfileCipher;
import org.whispersystems.signalservice.api.crypto.SignalServiceCipher;
import org.whispersystems.signalservice.api.crypto.UnidentifiedAccessPair;
import org.whispersystems.signalservice.api.crypto.UntrustedIdentityException;
import org.whispersystems.signalservice.api.messages.SignalServiceGroupV2;
import org.whispersystems.signalservice.api.messages.SignalServiceReceiptMessage;
import org.whispersystems.signalservice.api.messages.SignalServiceStickerManifestUpload;
-import org.whispersystems.signalservice.api.messages.SignalServiceStickerManifestUpload.StickerInfo;
import org.whispersystems.signalservice.api.messages.multidevice.BlockedListMessage;
import org.whispersystems.signalservice.api.messages.multidevice.ContactsMessage;
import org.whispersystems.signalservice.api.messages.multidevice.DeviceContact;
import org.whispersystems.signalservice.internal.push.UnsupportedDataMessageException;
import org.whispersystems.signalservice.internal.util.DynamicCredentialsProvider;
import org.whispersystems.signalservice.internal.util.Hex;
-import org.whispersystems.util.Base64;
import java.io.Closeable;
import java.io.File;
import java.io.FileInputStream;
-import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import java.util.stream.Collectors;
-import java.util.zip.ZipEntry;
-import java.util.zip.ZipFile;
import static org.asamk.signal.manager.ServiceConfig.CDS_MRENCLAVE;
import static org.asamk.signal.manager.ServiceConfig.capabilities;
private final String userAgent;
private SignalAccount account;
- private final PathConfig pathConfig;
private final SignalServiceAccountManager accountManager;
private final GroupsV2Api groupsV2Api;
private final GroupsV2Operations groupsV2Operations;
private final GroupHelper groupHelper;
private final PinHelper pinHelper;
private final AvatarStore avatarStore;
+ private final AttachmentStore attachmentStore;
Manager(
SignalAccount account,
String userAgent
) {
this.account = account;
- this.pathConfig = pathConfig;
this.serviceConfiguration = serviceConfiguration;
this.userAgent = userAgent;
this.groupsV2Operations = capabilities.isGv2() ? new GroupsV2Operations(ClientZkOperations.create(
groupsV2Api,
this::getGroupAuthForToday);
this.avatarStore = new AvatarStore(pathConfig.getAvatarsPath());
+ this.attachmentStore = new AttachmentStore(pathConfig.getAttachmentsPath());
}
public String getUsername() {
return new Manager(account, pathConfig, serviceConfiguration, userAgent);
}
+ public static List<String> getAllLocalUsernames(File settingsPath) {
+ PathConfig pathConfig = PathConfig.createDefault(settingsPath);
+ final File dataPath = pathConfig.getDataPath();
+ final File[] files = dataPath.listFiles();
+
+ if (files == null) {
+ return List.of();
+ }
+
+ return Arrays.stream(files)
+ .filter(File::isFile)
+ .map(File::getName)
+ .filter(file -> PhoneNumberFormatter.isValidNumber(file, null))
+ .collect(Collectors.toList());
+ }
+
public void checkAccountState() throws IOException {
if (accountManager.getPreKeysCount() < ServiceConfig.PREKEY_MINIMUM_COUNT) {
refreshPreKeys();
return null;
}
long now = new Date().getTime();
- // Profiles are cache for 24h before retrieving them again
+ // Profiles are cached for 24h before retrieving them again
if (!profileEntry.isRequestPending() && (
profileEntry.getProfile() == null || now - profileEntry.getLastUpdateTimestamp() > 24 * 60 * 60 * 1000
)) {
- ProfileKey profileKey = profileEntry.getProfileKey();
profileEntry.setRequestPending(true);
- SignalProfile profile;
+ final SignalServiceProfile encryptedProfile;
try {
- profile = retrieveRecipientProfile(address, profileKey);
+ encryptedProfile = profileHelper.retrieveProfileSync(address, SignalServiceProfile.RequestType.PROFILE)
+ .getProfile();
} catch (IOException e) {
logger.warn("Failed to retrieve profile, ignoring: {}", e.getMessage());
- profileEntry.setRequestPending(false);
return null;
+ } finally {
+ profileEntry.setRequestPending(false);
}
- profileEntry.setRequestPending(false);
+
+ final ProfileKey profileKey = profileEntry.getProfileKey();
+ final SignalProfile profile = decryptProfileAndDownloadAvatar(address, profileKey, encryptedProfile);
account.getProfileStore()
.updateProfile(address, profileKey, now, profile, profileEntry.getProfileKeyCredential());
return profile;
long now = new Date().getTime();
final ProfileKeyCredential profileKeyCredential = profileAndCredential.getProfileKeyCredential().orNull();
- final SignalProfile profile = decryptProfile(address,
+ final SignalProfile profile = decryptProfileAndDownloadAvatar(address,
profileEntry.getProfileKey(),
profileAndCredential.getProfile());
account.getProfileStore()
return profileEntry.getProfileKeyCredential();
}
- private SignalProfile retrieveRecipientProfile(
- SignalServiceAddress address, ProfileKey profileKey
- ) throws IOException {
- final SignalServiceProfile encryptedProfile = profileHelper.retrieveProfileSync(address,
- SignalServiceProfile.RequestType.PROFILE).getProfile();
-
- return decryptProfile(address, profileKey, encryptedProfile);
- }
-
- private SignalProfile decryptProfile(
+ private SignalProfile decryptProfileAndDownloadAvatar(
final SignalServiceAddress address, final ProfileKey profileKey, final SignalServiceProfile encryptedProfile
) {
if (encryptedProfile.getAvatar() != null) {
- try {
- retrieveProfileAvatar(address, encryptedProfile.getAvatar(), profileKey);
- } catch (Throwable e) {
- logger.warn("Failed to retrieve profile avatar, ignoring: {}", e.getMessage());
- }
+ downloadProfileAvatar(address, encryptedProfile.getAvatar(), profileKey);
}
- ProfileCipher profileCipher = new ProfileCipher(profileKey);
- try {
- String name;
- try {
- name = encryptedProfile.getName() == null
- ? null
- : new String(profileCipher.decryptName(Base64.decode(encryptedProfile.getName())));
- } catch (IOException e) {
- name = null;
- }
- String unidentifiedAccess;
- try {
- unidentifiedAccess = encryptedProfile.getUnidentifiedAccess() == null
- || !profileCipher.verifyUnidentifiedAccess(Base64.decode(encryptedProfile.getUnidentifiedAccess()))
- ? null
- : encryptedProfile.getUnidentifiedAccess();
- } catch (IOException e) {
- unidentifiedAccess = null;
- }
- return new SignalProfile(encryptedProfile.getIdentityKey(),
- name,
- unidentifiedAccess,
- encryptedProfile.isUnrestrictedUnidentifiedAccess(),
- encryptedProfile.getCapabilities());
- } catch (InvalidCiphertextException e) {
- return null;
- }
+ return ProfileUtils.decryptProfile(profileKey, encryptedProfile);
}
private Optional<SignalServiceAttachmentStream> createGroupAvatarAttachment(GroupId groupId) throws IOException {
return account.getGroupStore().getGroups();
}
- public Pair<Long, List<SendMessageResult>> sendGroupMessage(
- SignalServiceDataMessage.Builder messageBuilder, GroupId groupId
- ) throws IOException, GroupNotFoundException, NotAGroupMemberException {
- final GroupInfo g = getGroupForSending(groupId);
-
- GroupUtils.setGroupContext(messageBuilder, g);
- messageBuilder.withExpiration(g.getMessageExpirationTime());
-
- return sendMessage(messageBuilder, g.getMembersWithout(account.getSelfAddress()));
- }
-
public Pair<Long, List<SendMessageResult>> sendGroupMessage(
String messageText, List<String> attachments, GroupId groupId
) throws IOException, GroupNotFoundException, AttachmentInvalidException, NotAGroupMemberException {
return sendGroupMessage(messageBuilder, groupId);
}
- public Pair<Long, List<SendMessageResult>> sendQuitGroupMessage(GroupId groupId) throws GroupNotFoundException, IOException, NotAGroupMemberException {
+ public Pair<Long, List<SendMessageResult>> sendGroupMessage(
+ SignalServiceDataMessage.Builder messageBuilder, GroupId groupId
+ ) throws IOException, GroupNotFoundException, NotAGroupMemberException {
+ final GroupInfo g = getGroupForSending(groupId);
+
+ GroupUtils.setGroupContext(messageBuilder, g);
+ messageBuilder.withExpiration(g.getMessageExpirationTime());
+
+ return sendMessage(messageBuilder, g.getMembersWithout(account.getSelfAddress()));
+ }
+ public Pair<Long, List<SendMessageResult>> sendQuitGroupMessage(GroupId groupId) throws GroupNotFoundException, IOException, NotAGroupMemberException {
SignalServiceDataMessage.Builder messageBuilder;
final GroupInfo g = getGroupForUpdating(groupId);
return sendMessage(messageBuilder, g.getMembersWithout(account.getSelfAddress()));
}
+ public Pair<GroupId, List<SendMessageResult>> updateGroup(
+ GroupId groupId, String name, List<String> members, File avatarFile
+ ) throws IOException, GroupNotFoundException, AttachmentInvalidException, InvalidNumberException, NotAGroupMemberException {
+ return sendUpdateGroupMessage(groupId,
+ name,
+ members == null ? null : getSignalServiceAddresses(members),
+ avatarFile);
+ }
+
private Pair<GroupId, List<SendMessageResult>> sendUpdateGroupMessage(
GroupId groupId, String name, Collection<SignalServiceAddress> members, File avatarFile
) throws IOException, GroupNotFoundException, AttachmentInvalidException, NotAGroupMemberException {
return new Pair<>(g.getGroupId(), result.second());
}
- public Pair<GroupId, List<SendMessageResult>> joinGroup(
- GroupInviteLinkUrl inviteLinkUrl
- ) throws IOException, GroupLinkNotActiveException {
- return sendJoinGroupMessage(inviteLinkUrl);
- }
-
- private Pair<GroupId, List<SendMessageResult>> sendJoinGroupMessage(
- GroupInviteLinkUrl inviteLinkUrl
- ) throws IOException, GroupLinkNotActiveException {
- final DecryptedGroupJoinInfo groupJoinInfo = groupHelper.getDecryptedGroupJoinInfo(inviteLinkUrl.getGroupMasterKey(),
- inviteLinkUrl.getPassword());
- final GroupChange groupChange = groupHelper.joinGroup(inviteLinkUrl.getGroupMasterKey(),
- inviteLinkUrl.getPassword(),
- groupJoinInfo);
- final GroupInfoV2 group = getOrMigrateGroup(inviteLinkUrl.getGroupMasterKey(),
- groupJoinInfo.getRevision() + 1,
- groupChange.toByteArray());
-
- if (group.getGroup() == null) {
- // Only requested member, can't send update to group members
- return new Pair<>(group.getGroupId(), List.of());
- }
-
- final Pair<Long, List<SendMessageResult>> result = sendUpdateGroupMessage(group, group.getGroup(), groupChange);
-
- return new Pair<>(group.getGroupId(), result.second());
- }
-
- private Pair<Long, List<SendMessageResult>> sendUpdateGroupMessage(
- GroupInfoV2 group, DecryptedGroup newDecryptedGroup, GroupChange groupChange
- ) throws IOException {
- group.setGroup(newDecryptedGroup);
- final SignalServiceDataMessage.Builder messageBuilder = getGroupUpdateMessageBuilder(group,
- groupChange.toByteArray());
- account.getGroupStore().updateGroup(group);
- return sendMessage(messageBuilder, group.getMembersIncludingPendingWithout(account.getSelfAddress()));
- }
-
private void updateGroupV1(
final GroupInfoV1 g,
final String name,
}
}
- Pair<Long, List<SendMessageResult>> sendUpdateGroupMessage(
+ public Pair<GroupId, List<SendMessageResult>> joinGroup(
+ GroupInviteLinkUrl inviteLinkUrl
+ ) throws IOException, GroupLinkNotActiveException {
+ return sendJoinGroupMessage(inviteLinkUrl);
+ }
+
+ private Pair<GroupId, List<SendMessageResult>> sendJoinGroupMessage(
+ GroupInviteLinkUrl inviteLinkUrl
+ ) throws IOException, GroupLinkNotActiveException {
+ final DecryptedGroupJoinInfo groupJoinInfo = groupHelper.getDecryptedGroupJoinInfo(inviteLinkUrl.getGroupMasterKey(),
+ inviteLinkUrl.getPassword());
+ final GroupChange groupChange = groupHelper.joinGroup(inviteLinkUrl.getGroupMasterKey(),
+ inviteLinkUrl.getPassword(),
+ groupJoinInfo);
+ final GroupInfoV2 group = getOrMigrateGroup(inviteLinkUrl.getGroupMasterKey(),
+ groupJoinInfo.getRevision() + 1,
+ groupChange.toByteArray());
+
+ if (group.getGroup() == null) {
+ // Only requested member, can't send update to group members
+ return new Pair<>(group.getGroupId(), List.of());
+ }
+
+ final Pair<Long, List<SendMessageResult>> result = sendUpdateGroupMessage(group, group.getGroup(), groupChange);
+
+ return new Pair<>(group.getGroupId(), result.second());
+ }
+
+ private static int currentTimeDays() {
+ return (int) TimeUnit.MILLISECONDS.toDays(System.currentTimeMillis());
+ }
+
+ private GroupsV2AuthorizationString getGroupAuthForToday(
+ final GroupSecretParams groupSecretParams
+ ) throws IOException {
+ final int today = currentTimeDays();
+ // Returns credentials for the next 7 days
+ final HashMap<Integer, AuthCredentialResponse> credentials = groupsV2Api.getCredentials(today);
+ // TODO cache credentials until they expire
+ AuthCredentialResponse authCredentialResponse = credentials.get(today);
+ try {
+ return groupsV2Api.getGroupsV2AuthorizationString(account.getUuid(),
+ today,
+ groupSecretParams,
+ authCredentialResponse);
+ } catch (VerificationFailedException e) {
+ throw new IOException(e);
+ }
+ }
+
+ private Pair<Long, List<SendMessageResult>> sendUpdateGroupMessage(
+ GroupInfoV2 group, DecryptedGroup newDecryptedGroup, GroupChange groupChange
+ ) throws IOException {
+ group.setGroup(newDecryptedGroup);
+ final SignalServiceDataMessage.Builder messageBuilder = getGroupUpdateMessageBuilder(group,
+ groupChange.toByteArray());
+ account.getGroupStore().updateGroup(group);
+ return sendMessage(messageBuilder, group.getMembersIncludingPendingWithout(account.getSelfAddress()));
+ }
+
+ Pair<Long, List<SendMessageResult>> sendGroupInfoMessage(
GroupIdV1 groupId, SignalServiceAddress recipient
) throws IOException, NotAGroupMemberException, GroupNotFoundException, AttachmentInvalidException {
GroupInfoV1 g;
return sendMessage(messageBuilder, getSignalServiceAddresses(recipients));
}
+ public Pair<Long, SendMessageResult> sendSelfMessage(
+ String messageText, List<String> attachments
+ ) throws IOException, AttachmentInvalidException {
+ final SignalServiceDataMessage.Builder messageBuilder = SignalServiceDataMessage.newBuilder()
+ .withBody(messageText);
+ if (attachments != null) {
+ messageBuilder.withAttachments(AttachmentUtils.getSignalServiceAttachments(attachments));
+ }
+ return sendSelfMessage(messageBuilder);
+ }
+
public Pair<Long, List<SendMessageResult>> sendMessageReaction(
String emoji, boolean remove, String targetAuthor, long targetSentTimestamp, List<String> recipients
) throws IOException, InvalidNumberException {
account.save();
}
- public Pair<GroupId, List<SendMessageResult>> updateGroup(
- GroupId groupId, String name, List<String> members, File avatarFile
- ) throws IOException, GroupNotFoundException, AttachmentInvalidException, InvalidNumberException, NotAGroupMemberException {
- return sendUpdateGroupMessage(groupId,
- name,
- members == null ? null : getSignalServiceAddresses(members),
- avatarFile);
- }
-
/**
* Change the expiration timer for a contact
*/
* @return if successful, returns the URL to install the sticker pack in the signal app
*/
public String uploadStickerPack(File path) throws IOException, StickerPackInvalidException {
- SignalServiceStickerManifestUpload manifest = getSignalServiceStickerManifestUpload(path);
+ SignalServiceStickerManifestUpload manifest = StickerUtils.getSignalServiceStickerManifestUpload(path);
SignalServiceMessageSender messageSender = createMessageSender();
}
}
- private SignalServiceStickerManifestUpload getSignalServiceStickerManifestUpload(
- final File file
- ) throws IOException, StickerPackInvalidException {
- ZipFile zip = null;
- String rootPath = null;
-
- if (file.getName().endsWith(".zip")) {
- zip = new ZipFile(file);
- } else if (file.getName().equals("manifest.json")) {
- rootPath = file.getParent();
- } else {
- throw new StickerPackInvalidException("Could not find manifest.json");
- }
-
- JsonStickerPack pack = parseStickerPack(rootPath, zip);
-
- if (pack.stickers == null) {
- throw new StickerPackInvalidException("Must set a 'stickers' field.");
- }
-
- if (pack.stickers.isEmpty()) {
- throw new StickerPackInvalidException("Must include stickers.");
- }
-
- List<StickerInfo> stickers = new ArrayList<>(pack.stickers.size());
- for (JsonStickerPack.JsonSticker sticker : pack.stickers) {
- if (sticker.file == null) {
- throw new StickerPackInvalidException("Must set a 'file' field on each sticker.");
- }
-
- Pair<InputStream, Long> data;
- try {
- data = getInputStreamAndLength(rootPath, zip, sticker.file);
- } catch (IOException ignored) {
- throw new StickerPackInvalidException("Could not find find " + sticker.file);
- }
-
- String contentType = Utils.getFileMimeType(new File(sticker.file), null);
- StickerInfo stickerInfo = new StickerInfo(data.first(),
- data.second(),
- Optional.fromNullable(sticker.emoji).or(""),
- contentType);
- stickers.add(stickerInfo);
- }
-
- StickerInfo cover = null;
- if (pack.cover != null) {
- if (pack.cover.file == null) {
- throw new StickerPackInvalidException("Must set a 'file' field on the cover.");
- }
-
- Pair<InputStream, Long> data;
- try {
- data = getInputStreamAndLength(rootPath, zip, pack.cover.file);
- } catch (IOException ignored) {
- throw new StickerPackInvalidException("Could not find find " + pack.cover.file);
- }
-
- String contentType = Utils.getFileMimeType(new File(pack.cover.file), null);
- cover = new StickerInfo(data.first(),
- data.second(),
- Optional.fromNullable(pack.cover.emoji).or(""),
- contentType);
- }
-
- return new SignalServiceStickerManifestUpload(pack.title, pack.author, cover, stickers);
- }
-
- private static JsonStickerPack parseStickerPack(String rootPath, ZipFile zip) throws IOException {
- InputStream inputStream;
- if (zip != null) {
- inputStream = zip.getInputStream(zip.getEntry("manifest.json"));
- } else {
- inputStream = new FileInputStream((new File(rootPath, "manifest.json")));
- }
- return new ObjectMapper().readValue(inputStream, JsonStickerPack.class);
- }
-
- private static Pair<InputStream, Long> getInputStreamAndLength(
- final String rootPath, final ZipFile zip, final String subfile
- ) throws IOException {
- if (zip != null) {
- final ZipEntry entry = zip.getEntry(subfile);
- return new Pair<>(zip.getInputStream(entry), entry.getSize());
- } else {
- final File file = new File(rootPath, subfile);
- return new Pair<>(new FileInputStream(file), file.length());
- }
- }
-
void requestSyncGroups() throws IOException {
SignalServiceProtos.SyncMessage.Request r = SignalServiceProtos.SyncMessage.Request.newBuilder()
.setType(SignalServiceProtos.SyncMessage.Request.Type.GROUPS)
try {
sendSyncMessage(message);
} catch (UntrustedIdentityException e) {
- e.printStackTrace();
+ throw new AssertionError(e);
}
}
try {
sendSyncMessage(message);
} catch (UntrustedIdentityException e) {
- e.printStackTrace();
+ throw new AssertionError(e);
}
}
try {
sendSyncMessage(message);
} catch (UntrustedIdentityException e) {
- e.printStackTrace();
+ throw new AssertionError(e);
}
}
try {
sendSyncMessage(message);
} catch (UntrustedIdentityException e) {
- e.printStackTrace();
+ throw new AssertionError(e);
}
}
final int expirationTime = contact != null ? contact.messageExpirationTime : 0;
messageBuilder.withExpiration(expirationTime);
message = messageBuilder.build();
- if (address.matches(account.getSelfAddress())) {
- results.add(sendSelfMessage(message));
- } else {
- results.add(sendMessage(address, message));
- }
+ results.add(sendMessage(address, message));
}
return new Pair<>(timestamp, results);
}
}
}
+ private Pair<Long, SendMessageResult> sendSelfMessage(
+ SignalServiceDataMessage.Builder messageBuilder
+ ) throws IOException {
+ final long timestamp = System.currentTimeMillis();
+ messageBuilder.withTimestamp(timestamp);
+ getOrCreateMessagePipe();
+ getOrCreateUnidentifiedMessagePipe();
+ try {
+ final SignalServiceAddress address = getSelfAddress();
+
+ final ContactInfo contact = account.getContactStore().getContact(address);
+ final int expirationTime = contact != null ? contact.messageExpirationTime : 0;
+ messageBuilder.withExpiration(expirationTime);
+
+ SignalServiceDataMessage message = messageBuilder.build();
+ final SendMessageResult result = sendSelfMessage(message);
+ return new Pair<>(timestamp, result);
+ } finally {
+ account.save();
+ }
+ }
+
private SendMessageResult sendSelfMessage(SignalServiceDataMessage message) throws IOException {
SignalServiceMessageSender messageSender = createMessageSender();
account.getSignalProtocolStore().deleteAllSessions(source);
}
- private static int currentTimeDays() {
- return (int) TimeUnit.MILLISECONDS.toDays(System.currentTimeMillis());
- }
-
- private GroupsV2AuthorizationString getGroupAuthForToday(
- final GroupSecretParams groupSecretParams
- ) throws IOException {
- final int today = currentTimeDays();
- // Returns credentials for the next 7 days
- final HashMap<Integer, AuthCredentialResponse> credentials = groupsV2Api.getCredentials(today);
- // TODO cache credentials until they expire
- AuthCredentialResponse authCredentialResponse = credentials.get(today);
- try {
- return groupsV2Api.getGroupsV2AuthorizationString(account.getUuid(),
- today,
- groupSecretParams,
- authCredentialResponse);
- } catch (VerificationFailedException e) {
- throw new IOException(e);
- }
- }
-
private List<HandleAction> handleSignalServiceDataMessage(
SignalServiceDataMessage message,
boolean isSync,
if (groupInfo.getAvatar().isPresent()) {
SignalServiceAttachment avatar = groupInfo.getAvatar().get();
- if (avatar.isPointer()) {
- try {
- retrieveGroupAvatarAttachment(avatar.asPointer(), groupV1.getGroupId());
- } catch (IOException e) {
- logger.warn("Failed to retrieve avatar for group {}, ignoring: {}",
- groupId.toBase64(),
- e.getMessage());
- }
- }
+ downloadGroupAvatar(avatar, groupV1.getGroupId());
}
if (groupInfo.getName().isPresent()) {
}
case REQUEST_INFO:
if (groupV1 != null && !isSync) {
- actions.add(new SendGroupUpdateAction(source, groupV1.getGroupId()));
+ actions.add(new SendGroupInfoAction(source, groupV1.getGroupId()));
}
break;
}
}
if (message.getAttachments().isPresent() && !ignoreAttachments) {
for (SignalServiceAttachment attachment : message.getAttachments().get()) {
- if (attachment.isPointer()) {
- try {
- retrieveAttachment(attachment.asPointer());
- } catch (IOException e) {
- logger.warn("Failed to retrieve attachment ({}), ignoring: {}",
- attachment.asPointer().getRemoteId(),
- e.getMessage());
- }
- }
+ downloadAttachment(attachment);
}
}
if (message.getProfileKey().isPresent() && message.getProfileKey().get().length == 32) {
if (message.getPreviews().isPresent()) {
final List<SignalServiceDataMessage.Preview> previews = message.getPreviews().get();
for (SignalServiceDataMessage.Preview preview : previews) {
- if (preview.getImage().isPresent() && preview.getImage().get().isPointer()) {
- SignalServiceAttachmentPointer attachment = preview.getImage().get().asPointer();
- try {
- retrieveAttachment(attachment);
- } catch (IOException e) {
- logger.warn("Failed to retrieve preview image ({}), ignoring: {}",
- attachment.getRemoteId(),
- e.getMessage());
- }
+ if (preview.getImage().isPresent()) {
+ downloadAttachment(preview.getImage().get());
}
}
}
final SignalServiceDataMessage.Quote quote = message.getQuote().get();
for (SignalServiceDataMessage.Quote.QuotedAttachment quotedAttachment : quote.getAttachments()) {
- final SignalServiceAttachment attachment = quotedAttachment.getThumbnail();
- if (attachment != null && attachment.isPointer()) {
- try {
- retrieveAttachment(attachment.asPointer());
- } catch (IOException e) {
- logger.warn("Failed to retrieve quote attachment thumbnail ({}), ignoring: {}",
- attachment.asPointer().getRemoteId(),
- e.getMessage());
- }
+ final SignalServiceAttachment thumbnail = quotedAttachment.getThumbnail();
+ if (thumbnail != null) {
+ downloadAttachment(thumbnail);
}
}
}
storeProfileKeysFromMembers(group);
final String avatar = group.getAvatar();
if (avatar != null && !avatar.isEmpty()) {
- try {
- retrieveGroupAvatar(groupId, groupSecretParams, avatar);
- } catch (IOException e) {
- logger.warn("Failed to download group avatar, ignoring: {}", e.getMessage());
- }
+ downloadGroupAvatar(groupId, groupSecretParams, avatar);
}
}
groupInfoV2.setGroup(group);
try {
action.execute(this);
} catch (Throwable e) {
- e.printStackTrace();
+ logger.warn("Message action failed.", e);
}
}
}
try {
action.execute(this);
} catch (Throwable e) {
- e.printStackTrace();
+ logger.warn("Message action failed.", e);
}
}
account.save();
try {
action.execute(this);
} catch (Throwable e) {
- e.printStackTrace();
+ logger.warn("Message action failed.", e);
}
}
} else {
File tmpFile = null;
try {
tmpFile = IOUtils.createTempFile();
- try (InputStream attachmentAsStream = retrieveAttachmentAsStream(syncMessage.getGroups()
- .get()
- .asPointer(), tmpFile)) {
+ final SignalServiceAttachment groupsMessage = syncMessage.getGroups().get();
+ try (InputStream attachmentAsStream = retrieveAttachmentAsStream(groupsMessage.asPointer(),
+ tmpFile)) {
DeviceGroupsInputStream s = new DeviceGroupsInputStream(attachmentAsStream);
DeviceGroup g;
while ((g = s.read()) != null) {
}
if (g.getAvatar().isPresent()) {
- retrieveGroupAvatarAttachment(g.getAvatar().get(), syncGroup.getGroupId());
+ downloadGroupAvatar(g.getAvatar().get(), syncGroup.getGroupId());
}
syncGroup.inboxPosition = g.getInboxPosition().orNull();
syncGroup.archived = g.isArchived();
logger.warn("Failed to handle received sync groups “{}”, ignoring: {}",
tmpFile,
e.getMessage());
- e.printStackTrace();
} finally {
if (tmpFile != null) {
try {
account.getContactStore().updateContact(contact);
if (c.getAvatar().isPresent()) {
- retrieveContactAvatarAttachment(c.getAvatar().get(), contact.getAddress());
+ downloadContactAvatar(c.getAvatar().get(), contact.getAddress());
}
}
}
} catch (Exception e) {
- e.printStackTrace();
+ logger.warn("Failed to handle received sync contacts “{}”, ignoring: {}",
+ tmpFile,
+ e.getMessage());
} finally {
if (tmpFile != null) {
try {
return actions;
}
- private void retrieveContactAvatarAttachment(
- SignalServiceAttachment attachment, SignalServiceAddress address
- ) throws IOException {
- avatarStore.storeContactAvatar(address, outputStream -> retrieveAttachment(attachment, outputStream));
+ private void downloadContactAvatar(SignalServiceAttachment avatar, SignalServiceAddress address) {
+ try {
+ avatarStore.storeContactAvatar(address, outputStream -> retrieveAttachment(avatar, outputStream));
+ } catch (IOException e) {
+ logger.warn("Failed to download avatar for contact {}, ignoring: {}", address, e.getMessage());
+ }
}
- private void retrieveGroupAvatarAttachment(
- SignalServiceAttachment attachment, GroupId groupId
- ) throws IOException {
- avatarStore.storeGroupAvatar(groupId, outputStream -> retrieveAttachment(attachment, outputStream));
+ private void downloadGroupAvatar(SignalServiceAttachment avatar, GroupId groupId) {
+ try {
+ avatarStore.storeGroupAvatar(groupId, outputStream -> retrieveAttachment(avatar, outputStream));
+ } catch (IOException e) {
+ logger.warn("Failed to download avatar for group {}, ignoring: {}", groupId.toBase64(), e.getMessage());
+ }
+ }
+
+ private void downloadGroupAvatar(GroupId groupId, GroupSecretParams groupSecretParams, String cdnKey) {
+ try {
+ avatarStore.storeGroupAvatar(groupId,
+ outputStream -> retrieveGroupV2Avatar(groupSecretParams, cdnKey, outputStream));
+ } catch (IOException e) {
+ logger.warn("Failed to download avatar for group {}, ignoring: {}", groupId.toBase64(), e.getMessage());
+ }
}
- private void retrieveGroupAvatar(
- GroupId groupId, GroupSecretParams groupSecretParams, String cdnKey
+ private void downloadProfileAvatar(
+ SignalServiceAddress address, String avatarPath, ProfileKey profileKey
+ ) {
+ try {
+ avatarStore.storeProfileAvatar(address,
+ outputStream -> retrieveProfileAvatar(avatarPath, profileKey, outputStream));
+ } catch (Throwable e) {
+ logger.warn("Failed to download profile avatar, ignoring: {}", e.getMessage());
+ }
+ }
+
+ public File getAttachmentFile(SignalServiceAttachmentRemoteId attachmentId) {
+ return attachmentStore.getAttachmentFile(attachmentId);
+ }
+
+ private void downloadAttachment(final SignalServiceAttachment attachment) {
+ if (!attachment.isPointer()) {
+ logger.warn("Invalid state, can't store an attachment stream.");
+ }
+
+ SignalServiceAttachmentPointer pointer = attachment.asPointer();
+ if (pointer.getPreview().isPresent()) {
+ final byte[] preview = pointer.getPreview().get();
+ try {
+ attachmentStore.storeAttachmentPreview(pointer.getRemoteId(),
+ outputStream -> outputStream.write(preview, 0, preview.length));
+ } catch (IOException e) {
+ logger.warn("Failed to download attachment preview, ignoring: {}", e.getMessage());
+ }
+ }
+
+ try {
+ attachmentStore.storeAttachment(pointer.getRemoteId(),
+ outputStream -> retrieveAttachmentPointer(pointer, outputStream));
+ } catch (IOException e) {
+ logger.warn("Failed to download attachment ({}), ignoring: {}", pointer.getRemoteId(), e.getMessage());
+ }
+ }
+
+ private void retrieveGroupV2Avatar(
+ GroupSecretParams groupSecretParams, String cdnKey, OutputStream outputStream
) throws IOException {
GroupsV2Operations.GroupOperations groupOperations = groupsV2Operations.forGroup(groupSecretParams);
byte[] encryptedData = IOUtils.readFully(input);
byte[] decryptedData = groupOperations.decryptAvatar(encryptedData);
- avatarStore.storeGroupAvatar(groupId, outputStream -> outputStream.write(decryptedData));
+ outputStream.write(decryptedData);
} finally {
try {
Files.delete(tmpFile.toPath());
}
private void retrieveProfileAvatar(
- SignalServiceAddress address, String avatarPath, ProfileKey profileKey
+ String avatarPath, ProfileKey profileKey, OutputStream outputStream
) throws IOException {
File tmpFile = IOUtils.createTempFile();
try (InputStream input = messageReceiver.retrieveProfileAvatar(avatarPath,
tmpFile,
profileKey,
ServiceConfig.AVATAR_DOWNLOAD_FAILSAFE_MAX_SIZE)) {
- avatarStore.storeProfileAvatar(address, outputStream -> {
- // Use larger buffer size to prevent AssertionError: Need: 12272 but only have: 8192 ...
- IOUtils.copyStream(input, outputStream, (int) ServiceConfig.AVATAR_DOWNLOAD_FAILSAFE_MAX_SIZE);
- });
+ // Use larger buffer size to prevent AssertionError: Need: 12272 but only have: 8192 ...
+ IOUtils.copyStream(input, outputStream, (int) ServiceConfig.AVATAR_DOWNLOAD_FAILSAFE_MAX_SIZE);
} finally {
try {
Files.delete(tmpFile.toPath());
}
}
- public File getAttachmentFile(SignalServiceAttachmentRemoteId attachmentId) {
- return new File(pathConfig.getAttachmentsPath(), attachmentId.toString());
- }
-
- private void retrieveAttachment(SignalServiceAttachmentPointer pointer) throws IOException {
- IOUtils.createPrivateDirectories(pathConfig.getAttachmentsPath());
- retrieveAttachment(pointer, getAttachmentFile(pointer.getRemoteId()));
- }
-
- private void retrieveAttachment(
- SignalServiceAttachmentPointer pointer, File outputFile
- ) throws IOException {
- if (pointer.getPreview().isPresent()) {
- File previewFile = new File(outputFile + ".preview");
- try (OutputStream output = new FileOutputStream(previewFile)) {
- byte[] preview = pointer.getPreview().get();
- output.write(preview, 0, preview.length);
- } catch (FileNotFoundException e) {
- logger.warn("Failed to retrieve attachment preview, ignoring: {}", e.getMessage());
- }
- }
-
- try (OutputStream output = new FileOutputStream(outputFile)) {
- retrieveAttachment(pointer, output);
- }
- }
-
private void retrieveAttachment(
final SignalServiceAttachment attachment, final OutputStream outputStream
) throws IOException {
if (attachment.isPointer()) {
SignalServiceAttachmentPointer pointer = attachment.asPointer();
- retrieveAttachment(pointer, outputStream);
+ retrieveAttachmentPointer(pointer, outputStream);
} else {
SignalServiceAttachmentStream stream = attachment.asStream();
- AttachmentUtils.retrieveAttachment(stream, outputStream);
+ IOUtils.copyStream(stream.getInputStream(), outputStream);
}
}
- private void retrieveAttachment(
+ private void retrieveAttachmentPointer(
SignalServiceAttachmentPointer pointer, OutputStream outputStream
) throws IOException {
File tmpFile = IOUtils.createTempFile();
- try (InputStream input = messageReceiver.retrieveAttachment(pointer,
- tmpFile,
- ServiceConfig.MAX_ATTACHMENT_SIZE)) {
+ try (InputStream input = retrieveAttachmentAsStream(pointer, tmpFile)) {
IOUtils.copyStream(input, outputStream);
} catch (MissingConfigurationException | InvalidMessageException e) {
throw new IOException(e);
try {
sendVerifiedMessage(address, id.getIdentityKey(), TrustLevel.TRUSTED_VERIFIED);
} catch (IOException | UntrustedIdentityException e) {
- e.printStackTrace();
+ logger.warn("Failed to send verification sync message: {}", e.getMessage());
}
account.save();
return true;
try {
sendVerifiedMessage(address, id.getIdentityKey(), TrustLevel.TRUSTED_VERIFIED);
} catch (IOException | UntrustedIdentityException e) {
- e.printStackTrace();
+ logger.warn("Failed to send verification sync message: {}", e.getMessage());
}
account.save();
return true;
try {
sendVerifiedMessage(address, id.getIdentityKey(), TrustLevel.TRUSTED_UNVERIFIED);
} catch (IOException | UntrustedIdentityException e) {
- e.printStackTrace();
+ logger.warn("Failed to send verification sync message: {}", e.getMessage());
}
}
}
git.nmode.ca / signal-cli / blobdiff
