Squash and clean of old PRs, move towards sending cleartext again

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

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) {

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
 

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

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();
 

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,

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;

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;
 })();

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;

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;

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,

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;