diff --git a/app/sql.js b/app/sql.js index 5ff936e18..901be18d7 100644 --- a/app/sql.js +++ b/app/sql.js @@ -97,6 +97,7 @@ module.exports = { updateConversation, removeConversation, getAllConversations, + getAllPublicConversations, getPubKeysWithFriendStatus, getAllConversationIds, getAllPrivateConversations, @@ -783,12 +784,12 @@ async function updateToLokiSchemaVersion1(currentVersion, instance) { await instance.run('BEGIN TRANSACTION;'); const publicChatData = { - id: '06lokiPublicChat', + id: 'publicChat:1@chat.lokinet.org', friendRequestStatus: 4, // Friends sealedSender: 0, sessionResetStatus: 0, swarmNodes: [], - type: 'private', + type: 'group', profile: { displayName: 'Loki Public Chat', }, @@ -1604,6 +1605,17 @@ async function getAllPrivateConversations() { return map(rows, row => jsonToObject(row.json)); } +async function getAllPublicConversations() { + const rows = await db.all( + `SELECT json FROM conversations WHERE + type = 'group' AND + id LIKE 'publicChat:%' + ORDER BY id ASC;` + ); + + return map(rows, row => jsonToObject(row.json)); +} + async function getAllGroupsInvolvingId(id) { const rows = await db.all( `SELECT json FROM conversations WHERE diff --git a/js/background.js b/js/background.js index 3cd81dcbd..544deb735 100644 --- a/js/background.js +++ b/js/background.js @@ -204,9 +204,30 @@ window.log.info('Storage fetch'); storage.fetch(); - const initAPIs = () => { + const initAPIs = async () => { const ourKey = textsecure.storage.user.getNumber(); window.lokiMessageAPI = new window.LokiMessageAPI(ourKey); + window.lokiPublicChatAPI = new window.LokiPublicChatAPI(ourKey); + const publicConversations = await window.Signal.Data.getAllPublicConversations( + { + ConversationCollection: Whisper.ConversationCollection, + } + ); + publicConversations.forEach(conversation => { + const settings = conversation.getPublicSource(); + window.log.info(`Setting up public conversation for ${conversation.id}`); + const publicChatServer = window.lokiPublicChatAPI.findOrCreateServer( + settings.server + ); + if (publicChatServer) { + publicChatServer.findOrCreateChannel( + settings.channel_id, + conversation.id + ); + } else { + window.log.warn(`Could not set up channel for ${conversation.id}`); + } + }); window.lokiP2pAPI = new window.LokiP2pAPI(ourKey); window.lokiP2pAPI.on('pingContact', pubKey => { const isPing = true; @@ -246,7 +267,7 @@ if (Whisper.Registration.isDone()) { startLocalLokiServer(); - initAPIs(); + await initAPIs(); } const currentPoWDifficulty = storage.get('PoWDifficulty', null); @@ -729,6 +750,15 @@ } }); + Whisper.events.on('publicMessageSent', ({ pubKey, timestamp }) => { + try { + const conversation = ConversationController.get(pubKey); + conversation.onPublicMessageSent(pubKey, timestamp); + } catch (e) { + window.log.error('Error setting public on message'); + } + }); + Whisper.events.on('password-updated', () => { if (appView && appView.inboxView) { appView.inboxView.trigger('password-updated'); @@ -1245,6 +1275,18 @@ return handleProfileUpdate({ data, confirm, messageDescriptor }); } + const ourNumber = textsecure.storage.user.getNumber(); + const descriptorId = await textsecure.MessageReceiver.arrayBufferToString( + messageDescriptor.id + ); + if ( + messageDescriptor.type === 'group' && + descriptorId.match(/^publicChat:/) && + data.source === ourNumber + ) { + // Remove public chat messages to ourselves + return event.confirm(); + } const message = await createMessage(data); const isDuplicate = await isMessageDuplicate(message); if (isDuplicate) { @@ -1378,6 +1420,7 @@ type: 'incoming', unread: 1, isP2p: data.isP2p, + isPublic: data.isPublic, }; if (data.friendRequest) { diff --git a/js/models/conversations.js b/js/models/conversations.js index 15d265021..b19674da6 100644 --- a/js/models/conversations.js +++ b/js/models/conversations.js @@ -193,6 +193,9 @@ isMe() { return this.id === this.ourNumber; }, + isPublic() { + return this.id.match(/^publicChat:/); + }, isBlocked() { return BlockedNumberController.isBlocked(this.id); }, @@ -365,6 +368,11 @@ await Promise.all(messages.map(m => m.setIsP2p(true))); }, + async onPublicMessageSent(pubKey, timestamp) { + const messages = this._getMessagesWithTimestamp(pubKey, timestamp); + await Promise.all(messages.map(m => m.setIsPublic(true))); + }, + async onNewMessage(message) { await this.updateLastMessage(); @@ -1347,6 +1355,9 @@ const options = this.getSendOptions(); options.messageType = message.get('type'); + if (this.isPublic()) { + options.publicEndpoint = this.getEndpoint(); + } const groupNumbers = this.getRecipients(); @@ -2015,6 +2026,26 @@ getNickname() { return this.get('nickname'); }, + // maybe "Backend" instead of "Source"? + getPublicSource() { + if (!this.isPublic()) { + return null; + } + return { + server: this.get('server'), + channel_id: this.get('channelId'), + }; + }, + // FIXME: remove or add public and/or "sending" hint to name... + getEndpoint() { + if (!this.isPublic()) { + return null; + } + const server = this.get('server'); + const channelId = this.get('channelId'); + const endpoint = `${server}/channels/${channelId}/messages`; + return endpoint; + }, // SIGNAL PROFILES diff --git a/js/models/messages.js b/js/models/messages.js index 8f91658a8..9bc338259 100644 --- a/js/models/messages.js +++ b/js/models/messages.js @@ -670,6 +670,7 @@ expirationLength, expirationTimestamp, isP2p: !!this.get('isP2p'), + isPublic: !!this.get('isPublic'), onCopyText: () => this.copyText(), onReply: () => this.trigger('reply', this), @@ -1238,6 +1239,17 @@ Message: Whisper.Message, }); }, + async setIsPublic(isPublic) { + if (_.isEqual(this.get('isPublic'), isPublic)) return; + + this.set({ + isPublic: !!isPublic, + }); + + await window.Signal.Data.saveMessage(this.attributes, { + Message: Whisper.Message, + }); + }, send(promise) { this.trigger('pending'); return promise diff --git a/js/modules/data.js b/js/modules/data.js index e5a9e1af1..347fc36fc 100644 --- a/js/modules/data.js +++ b/js/modules/data.js @@ -118,6 +118,7 @@ module.exports = { getPubKeysWithFriendStatus, getAllConversationIds, getAllPrivateConversations, + getAllPublicConversations, getAllGroupsInvolvingId, searchConversations, @@ -739,6 +740,14 @@ async function getAllConversationIds() { return ids; } +async function getAllPublicConversations({ ConversationCollection }) { + const conversations = await channels.getAllPublicConversations(); + + const collection = new ConversationCollection(); + collection.add(conversations); + return collection; +} + async function getAllPrivateConversations({ ConversationCollection }) { const conversations = await channels.getAllPrivateConversations(); diff --git a/js/modules/loki_message_api.js b/js/modules/loki_message_api.js index 199448a57..87c3ec0d3 100644 --- a/js/modules/loki_message_api.js +++ b/js/modules/loki_message_api.js @@ -4,6 +4,7 @@ const _ = require('lodash'); const { rpc } = require('./loki_rpc'); +const nodeFetch = require('node-fetch'); const DEFAULT_CONNECTIONS = 3; const MAX_ACCEPTABLE_FAILURES = 1; @@ -75,13 +76,57 @@ class LokiMessageAPI { } async sendMessage(pubKey, data, messageTimeStamp, ttl, options = {}) { - const { isPing = false, numConnections = DEFAULT_CONNECTIONS } = options; + const { + isPing = false, + numConnections = DEFAULT_CONNECTIONS, + publicEndpoint = null, + } = options; // Data required to identify a message in a conversation const messageEventData = { pubKey, timestamp: messageTimeStamp, }; + // FIXME: should have public/sending(ish hint) in the option to make + // this more obvious... + if (publicEndpoint) { + // could we emit back to LokiPublicChannelAPI somehow? + const { profile } = data; + let displayName = 'Anonymous'; + if (profile && profile.displayName) { + ({ displayName } = profile); + } + const payload = { + text: data.body, + annotations: [ + { + type: 'network.loki.messenger.publicChat', + value: { + timestamp: messageTimeStamp, + from: displayName, + source: this.ourKey, + }, + }, + ], + }; + try { + await nodeFetch(publicEndpoint, { + method: 'post', + headers: { + 'Content-Type': 'application/json', + Authorization: 'Bearer loki', + }, + body: JSON.stringify(payload), + }); + window.Whisper.events.trigger('publicMessageSent', messageEventData); + return; + } catch (e) { + throw new window.textsecure.PublicChatError( + 'Failed to send public chat message.' + ); + } + } + const data64 = dcodeIO.ByteBuffer.wrap(data).toString('base64'); const p2pSuccess = await trySendP2p( pubKey, diff --git a/js/modules/loki_public_chat_api.js b/js/modules/loki_public_chat_api.js new file mode 100644 index 000000000..b2b55c4e2 --- /dev/null +++ b/js/modules/loki_public_chat_api.js @@ -0,0 +1,209 @@ +/* global log, textsecure */ +const EventEmitter = require('events'); +const nodeFetch = require('node-fetch'); +const { URL, URLSearchParams } = require('url'); + +const GROUPCHAT_POLL_EVERY = 1000; // 1 second + +// singleton to relay events to libtextsecure/message_receiver +class LokiPublicChatAPI extends EventEmitter { + constructor(ourKey) { + super(); + this.ourKey = ourKey; + this.lastGot = {}; + this.servers = []; + } + findOrCreateServer(hostport) { + let thisServer = null; + log.info(`LokiPublicChatAPI looking for ${hostport}`); + this.servers.some(server => { + // if we already have this hostport registered + if (server.server === hostport) { + thisServer = server; + return true; + } + return false; + }); + if (thisServer === null) { + thisServer = new LokiPublicServerAPI(this, hostport); + this.servers.push(thisServer); + } + return thisServer; + } +} + +class LokiPublicServerAPI { + constructor(chatAPI, hostport) { + this.chatAPI = chatAPI; + this.server = hostport; + this.channels = []; + } + findOrCreateChannel(channelId, conversationId) { + let thisChannel = null; + this.channels.forEach(channel => { + if ( + channel.channelId === channelId && + channel.conversationId === conversationId + ) { + thisChannel = channel; + } + }); + if (thisChannel === null) { + thisChannel = new LokiPublicChannelAPI(this, channelId, conversationId); + this.channels.push(thisChannel); + } + return thisChannel; + } + unregisterChannel(channelId) { + // find it, remove it + // if no channels left, request we deregister server + return channelId || this; // this is just to make eslint happy + } +} + +class LokiPublicChannelAPI { + constructor(serverAPI, channelId, conversationId) { + this.serverAPI = serverAPI; + this.channelId = channelId; + this.baseChannelUrl = `${serverAPI.server}/channels/${this.channelId}`; + this.groupName = 'unknown'; + this.conversationId = conversationId; + this.lastGot = 0; + log.info(`registered LokiPublicChannel ${channelId}`); + // start polling + this.pollForMessages(); + } + + async pollForChannel(source, endpoint) { + // groupName will be loaded from server + const url = new URL(this.baseChannelUrl); + /* + const params = { + include_annotations: 1, + }; + */ + let res; + let success = true; + try { + res = await nodeFetch(url); + } catch (e) { + success = false; + } + + const response = await res.json(); + if (response.meta.code !== 200) { + success = false; + } + // update this.groupId + return endpoint || success; + } + + async pollForDeletions() { + // let id = 0; + // read all messages from 0 to current + // delete local copies if server state has changed to delete + // run every minute + const url = new URL(this.baseChannelUrl); + /* + const params = { + include_annotations: 1, + }; + */ + let res; + let success = true; + try { + res = await nodeFetch(url); + } catch (e) { + success = false; + } + + const response = await res.json(); + if (response.meta.code !== 200) { + success = false; + } + return success; + } + + async pollForMessages() { + const url = new URL(`${this.baseChannelUrl}/messages`); + const params = { + include_annotations: 1, + count: -20, + }; + if (this.lastGot) { + params.since_id = this.lastGot; + } + url.search = new URLSearchParams(params); + + let res; + let success = true; + try { + res = await nodeFetch(url); + } catch (e) { + success = false; + } + + const response = await res.json(); + if (response.meta.code !== 200) { + success = false; + } + + if (success) { + let receivedAt = new Date().getTime(); + response.data.forEach(adnMessage => { + // FIXME: create proper message for this message.DataMessage.body + let timestamp = new Date(adnMessage.created_at).getTime(); + let from = adnMessage.user.username; + let source; + if (adnMessage.annotations.length) { + const noteValue = adnMessage.annotations[0].value; + ({ from, timestamp, source } = noteValue); + } + + const messageData = { + friendRequest: false, + source, + sourceDevice: 1, + timestamp, + serverTimestamp: timestamp, + receivedAt, + isPublic: true, + message: { + body: adnMessage.text, + attachments: [], + group: { + id: this.conversationId, + type: textsecure.protobuf.GroupContext.Type.DELIVER, + }, + flags: 0, + expireTimer: 0, + profileKey: null, + timestamp, + received_at: receivedAt, + sent_at: timestamp, + quote: null, + contact: [], + preview: [], + profile: { + displayName: from, + }, + }, + }; + receivedAt += 1; // Ensure different arrival times + + this.serverAPI.chatAPI.emit('publicMessage', { + message: messageData, + }); + this.lastGot = !this.lastGot + ? adnMessage.id + : Math.max(this.lastGot, adnMessage.id); + }); + } + + setTimeout(() => { + this.pollForMessages(); + }, GROUPCHAT_POLL_EVERY); + } +} + +module.exports = LokiPublicChatAPI; diff --git a/libtextsecure/errors.js b/libtextsecure/errors.js index c97d21fe3..7e16d4ecf 100644 --- a/libtextsecure/errors.js +++ b/libtextsecure/errors.js @@ -273,6 +273,18 @@ } inherit(ReplayableError, TimestampError); + function PublicChatError(message) { + this.name = 'PublicChatError'; + this.message = message; + Error.call(this, message); + + // Maintains proper stack trace, where our error was thrown (only available on V8) + // via https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error + if (Error.captureStackTrace) { + Error.captureStackTrace(this); + } + } + window.textsecure.UnregisteredUserError = UnregisteredUserError; window.textsecure.SendMessageNetworkError = SendMessageNetworkError; window.textsecure.IncomingIdentityKeyError = IncomingIdentityKeyError; @@ -292,4 +304,5 @@ window.textsecure.WrongSwarmError = WrongSwarmError; window.textsecure.WrongDifficultyError = WrongDifficultyError; window.textsecure.TimestampError = TimestampError; + window.textsecure.PublicChatError = PublicChatError; })(); diff --git a/libtextsecure/message_receiver.js b/libtextsecure/message_receiver.js index 9c356df08..db640c623 100644 --- a/libtextsecure/message_receiver.js +++ b/libtextsecure/message_receiver.js @@ -13,6 +13,7 @@ /* global GroupBuffer: false */ /* global WebSocketResource: false */ /* global localLokiServer: false */ +/* global lokiPublicChatAPI: false */ /* global localServerPort: false */ /* global lokiMessageAPI: false */ /* global lokiP2pAPI: false */ @@ -75,6 +76,7 @@ MessageReceiver.prototype.extend({ }); this.httpPollingResource.pollServer(); localLokiServer.on('message', this.handleP2pMessage.bind(this)); + lokiPublicChatAPI.on('publicMessage', this.handlePublicMessage.bind(this)); this.startLocalServer(); // TODO: Rework this socket stuff to work with online messaging @@ -142,6 +144,12 @@ MessageReceiver.prototype.extend({ }; this.httpPollingResource.handleMessage(message, options); }, + handlePublicMessage({ message }) { + const ev = new Event('message'); + ev.confirm = function confirmTerm() {}; + ev.data = message; + this.dispatchAndWait(ev); + }, stopProcessing() { window.log.info('MessageReceiver: stopProcessing requested'); this.stoppingProcessing = true; diff --git a/libtextsecure/outgoing_message.js b/libtextsecure/outgoing_message.js index ad12ee51a..a0ab663a4 100644 --- a/libtextsecure/outgoing_message.js +++ b/libtextsecure/outgoing_message.js @@ -43,9 +43,17 @@ function OutgoingMessage( this.failoverNumbers = []; this.unidentifiedDeliveries = []; - const { numberInfo, senderCertificate, online, messageType, isPing } = + const { + numberInfo, + senderCertificate, + online, + messageType, + isPing, + publicEndpoint, + } = options || {}; this.numberInfo = numberInfo; + this.publicEndpoint = publicEndpoint; this.senderCertificate = senderCertificate; this.online = online; this.messageType = messageType || 'outgoing'; @@ -193,6 +201,9 @@ OutgoingMessage.prototype = { numConnections: NUM_SEND_CONNECTIONS, isPing: this.isPing, }; + if (this.publicEndpoint) { + options.publicEndpoint = this.publicEndpoint; + } await lokiMessageAPI.sendMessage(pubKey, data, timestamp, ttl, options); } catch (e) { if (e.name === 'HTTPError' && (e.code !== 409 && e.code !== 410)) { @@ -259,6 +270,21 @@ OutgoingMessage.prototype = { }, doSendMessage(number, deviceIds, recurse) { const ciphers = {}; + if (this.publicEndpoint) { + return this.transmitMessage( + number, + this.message.dataMessage, + this.timestamp, + 0 // ttl + ) + .then(() => { + this.successfulNumbers[this.successfulNumbers.length] = number; + this.numberCompleted(); + }) + .catch(error => { + throw error; + }); + } /* Disabled because i'm not sure how senderCertificate works :thinking: const { numberInfo, senderCertificate } = this; diff --git a/libtextsecure/sendmessage.js b/libtextsecure/sendmessage.js index c2be038d8..59cf18447 100644 --- a/libtextsecure/sendmessage.js +++ b/libtextsecure/sendmessage.js @@ -942,7 +942,10 @@ MessageSender.prototype = { options ) { const me = textsecure.storage.user.getNumber(); - const numbers = groupNumbers.filter(number => number !== me); + let numbers = groupNumbers.filter(number => number !== me); + if (options.publicEndpoint) { + numbers = [groupId]; + } const attrs = { recipients: numbers, body: messageText, diff --git a/preload.js b/preload.js index be63b33f6..7ff52dc3d 100644 --- a/preload.js +++ b/preload.js @@ -324,6 +324,8 @@ window.LokiP2pAPI = require('./js/modules/loki_p2p_api'); window.LokiMessageAPI = require('./js/modules/loki_message_api'); +window.LokiPublicChatAPI = require('./js/modules/loki_public_chat_api'); + window.LocalLokiServer = require('./libloki/modules/local_loki_server'); window.localServerPort = config.localServerPort;