├── COPYING
├── README.md
├── doc
    ├── SoulseekProtocol – Museek+.html
    ├── SoulseekProtocol – Museek+_files
    │   ├── babel.js
    │   ├── folding.js
    │   ├── jquery.js
    │   ├── main.css
    │   ├── museek_banner_github.png
    │   ├── search.js
    │   ├── trac.css
    │   ├── trac.js
    │   ├── trac_logo_mini.png
    │   └── wiki.css
    └── soulseek_protocol.html
├── index.js
├── lib
    ├── blacklist.json
    ├── build-list.js
    ├── check-port.js
    ├── client
    │   ├── handlers.js
    │   └── index.js
    ├── distrib-peer
    │   ├── handlers.js
    │   └── index.js
    ├── make-token.js
    ├── message
    │   ├── decode-list.js
    │   ├── decode-room.js
    │   ├── emitter.js
    │   ├── encode-list.js
    │   ├── from-distrib.js
    │   ├── from-peer.js
    │   ├── from-server.js
    │   ├── index.js
    │   ├── to-distrib.js
    │   ├── to-peer.js
    │   └── to-server.js
    ├── nat-pmp-map.js
    ├── peer-server.js
    ├── peer
    │   ├── handlers.js
    │   └── index.js
    ├── search-share-list.js
    ├── soul-sock.js
    ├── transfer-peer
    │   ├── handlers.js
    │   └── index.js
    └── upload-speed.js
├── livelook.svg
├── package.json
└── test.js


/README.md:
--------------------------------------------------------------------------------
  1 | # livelook 👀
  2 | <img align="right" width="176" height="220" src="./livelook.svg">
  3 | 
  4 | a [soulseek](https://en.wikipedia.org/wiki/Soulseek) client written in
  5 | javascript. soulseek allows users from around the world to connect to each other
  6 | directly and share music (and other stuff).
  7 | 
  8 | >Soulseek is an ad-free, spyware free, just plain free file sharing network for
  9 | >Windows, Mac and Linux. Our rooms, search engine and search correlation system
 10 | >make it easy for you to find people with similar interests, and make new
 11 | >discoveries!
 12 | >
 13 | >-- [About Soulseek | Soulseek](https://www.slsknet.org/news/node/680)
 14 | 
 15 | features supported:
 16 | * [nat pmp](https://en.wikipedia.org/wiki/NAT_Port_Mapping_Protocol) and
 17 | [upnp](https://en.wikipedia.org/wiki/Universal_Plug_and_Play) port-forwarding
 18 | * chat rooms and private messages (including direct connections)
 19 | * browsing user's share lists and vice versa
 20 | * searching the network's files and responding to distributed searches
 21 | * downloading and uploading with automatically updating share list
 22 | 
 23 | <div style="clear: both;">
 24 | i mainly tested this against nicotine-plus, but it works with soulseekqt too.
 25 | </div>
 26 | 
 27 | ## example
 28 | ```javascript
 29 | const LiveLook = require('./');
 30 | const fs = require('fs');
 31 | 
 32 | let livelook = new LiveLook({
 33 |     username: 'toadtripler',
 34 |     password: 'not my password',
 35 |     sharedFolder: './mp3s',
 36 |     autojoin: [ 'nicotine' ]
 37 | });
 38 | 
 39 | livelook.on('error', console.error);
 40 | 
 41 | livelook.login((err, res) => {
 42 |     if (err || !res.success) {
 43 |         return console.log('login failed');
 44 |     }
 45 | 
 46 |     livelook.on('sayChatroom', msg => {
 47 |         console.log(`[${msg.room}] <${msg.username}> ${msg.message}`);
 48 |     });
 49 | 
 50 |     livelook.on('messageUser', msg => {
 51 |         console.log(`<${msg.username}> ${msg.message}`);
 52 |     });
 53 | 
 54 |     livelook.search('hot dad web love', (err, res) => {
 55 |         if (err) {
 56 |             return console.error(err);
 57 |         }
 58 | 
 59 |         res = res.filter(item => item.slotsFree);
 60 | 
 61 |         if (!res) {
 62 |             console.log('no files found :(');
 63 |             return;
 64 |         }
 65 | 
 66 |         let downloaded = fs.createWriteStream('hot-dad-web-love.mp3');
 67 |         res = res.sort((a, b) => a.speed > b.speed ? -1: 0)[0];
 68 |         livelook.downloadFile(res.username, res.file).pipe(downloaded);
 69 |         downloaded.on('end', () => {
 70 |             livelook.messageUser(res.username, `hey thanks for ${res.file}!`);
 71 |         });
 72 |     });
 73 | });
 74 | ```
 75 | ## install
 76 | 
 77 | 	$ npm install --save livelook
 78 | 
 79 | ## api
 80 | ### livelook = new LiveLook(args)
 81 | create a new `livelook` instance.
 82 | 
 83 | ```javascript
 84 | // args
 85 | {
 86 |     username: '',
 87 |     password: '',
 88 |     server: 'server.slsknet.org',
 89 |     port: 2242, // port for server above, NOT the port we listen on
 90 |     waitPort: 2234, // port for peer server. will retry multiple options if fail
 91 |     sharedFolder: './mp3s',
 92 |     downloadFolder: './downloads',
 93 |     description: 'user biography',
 94 |     autojoin: [ 'chatrooms', 'joined', 'automatically' ],
 95 |     maxPeers: 100,
 96 |     uploadSlots: 2, // maximum uploads allowed at one time
 97 |     uploadThrottle: 56 * 1024, // speed to throttle uploads in bytes
 98 |     downloadThrottle: 56 * 1024
 99 | }
100 | ```
101 | 
102 | ### livelook.init([done])
103 | initialize our share list and connect to the soulseek server. you don't need to
104 | call this if you just use login below.
105 | 
106 | ### livelook.login([username, password, done])
107 | login to the soulseek server, and initialize our peer server if it isn't
108 | already. username and password are optional if the instance has them.
109 | 
110 | ### livelook.refreshShareList([done])
111 | re-scan `livelook.sharedFolder` and repopulate `livelook.shareList`. this is
112 | what other users see when they browse us, or when we respond to searches.
113 | 
114 | ### livelook.sayChatroom(room, message)
115 | send a message to a chatroom.
116 | 
117 | ### livelook.leaveChatroom(room)
118 | leave a chatroom and stop receiving messages from it.
119 | 
120 | ### livelook.joinRoom(room)
121 | join a chatroom and start accepting messages from it.
122 | 
123 | ### livelook.messageUser(username, message)
124 | send a private message to a specific user.
125 | 
126 | ### livelook.setStatus(status)
127 | set our online/away status.
128 | 
129 | `status` can be a `Number` (1 for away, 2 for online), `'away'` or `'online'`.
130 | 
131 | ### livelook.refreshUploadSpeed([done])
132 | re-calculate our upload speed from [speedtest.net](https://www.speedtest.net/).
133 | 
134 | ### livelook.getPeerAddress(username, done)
135 | get a peer's ip address and port based on their username.
136 | 
137 | ### livelook.getPeerByUsername(username, done)
138 | get a peer instance based on a username. this will first check our pre-existing
139 | peers, then it tries to make a direct connection to the peer until finally
140 | requesting the server connect the peer to us.
141 | 
142 | ### livelook.getShareFileList(username, done)
143 | get all the files a user is sharing. may take a while as some people share
144 | large amounts of files, and the message must be decompressed.
145 | 
146 | ### livelook.searchUserShares(username, query, done)
147 | search a user's shares for a query. nicotine users max out at 50 by default.
148 | 
149 | ### livelook.getUserInfo(username, done)
150 | get a user's description (biography), picture (avatar) as a buffer,
151 | upload slots, queue size and slots free.
152 | 
153 | ### livelook.getFolderContents(username, folder, done)
154 | get a list of all the files in the specified folder.
155 | 
156 | ### livelook.downloadFile(username, file, [fileStart = 0])
157 | download a file from a user. this returns a `ReadableStream`, and will also
158 | emit a `queue` event with its position if we can't download it immediately. pass
159 | in `fileStart` to indicate where to begin downloading the file in bytes (to
160 | resume interrupted downloads).
161 | 
162 | ### livelook.searchFiles(query, [args = { timeout, max }, done])
163 | search other peers for files. this returns a `ReadableStream` in `objectMode`.
164 | on search results it will emit `data` events containing the following:
165 | 
166 | ```javascript
167 | { username, file, size, bitrate, vbr, duration, slotsFree, speed, queueSize }
168 | ```
169 | 
170 | if `done` is provided, the terms will be concatted and passed in either after
171 | the timeout finishes or the max results are reached.
172 | 
173 | ## how it works
174 | soulseek is largely peer-to-peer, but still relies on a central server for
175 | chat rooms, messaging, piercing firewalls and finding peers.
176 | 
177 | ### initializing
178 | first we set up a local server to accept peer connections (and port forward with
179 | nat pmp or upnp if possible). then we connect to slsknet.org (or any other
180 | soulseek server) as a separate client and login. we can now begin to chat and
181 | browse.
182 | 
183 | ### finding peers
184 | we can connect to peers by fetching their ip and port based on their username
185 | from the soulseek server, but if they aren't port-forwarded this will fail. the
186 | next step is to send a connection request via the soulseek server to tell them
187 | to connect to us. if this fails, there is no way for them to connect to us. this
188 | is why it's a good idea to enable nat pmp or port forward manually.
189 | 
190 | ### searching
191 | after logging in, we tell the server we're orphaned and have no parents. after
192 | an arbitrary amount of time (usually around 30 seconds), the server gives a list
193 | of potential parents. once we connect to one successfully, we can also become a
194 | parent. our parent will contionously send us search requests from other peers.
195 | we can respond to them directly if we have the results, but also send the
196 | request to all of our children so they can do the same.
197 | 
198 | ## see also
199 | * [Soulseek.NET](https://github.com/jpdillingham/Soulseek.NET) by @jpdillingham
200 | * [museek-plus](https://github.com/eLvErDe/museek-plus) by @eLvErDe
201 |     * [protocol docs](https://htmlpreview.github.io/?http://github.com/misterhat/livelook/blob/master/doc/SoulseekProtocol%20%E2%80%93%20Museek%2B.html)
202 | * [nicotine-plus](https://github.com/Nicotine-Plus/nicotine-plus)
203 | * [slsk-client](https://github.com/f-hj/slsk-client) by @f-hj.
204 | * [soleseek protocol docs](https://htmlpreview.github.io/?https://github.com/misterhat/livelook/blob/master/doc/soulseek_protocol.html)
205 | 
206 | ## donate
207 | [donate to keep the central server alive!](https://www.slsknet.org/donate.php)
208 | 
209 | ## license
210 | Copyright (C) 2019  Zorian Medwid
211 | 
212 | This program is free software: you can redistribute it and/or modify
213 | it under the terms of the GNU Affero General Public License as
214 | published by the Free Software Foundation, either version 3 of the
215 | License, or (at your option) any later version.
216 | 
217 | This program is distributed in the hope that it will be useful,
218 | but WITHOUT ANY WARRANTY; without even the implied warranty of
219 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
220 | GNU Affero General Public License for more details.
221 | 
222 | You should have received a copy of the GNU Affero General Public License
223 | along with this program.  If not, see http://www.gnu.org/licenses/.
224 | 
225 | **You may not distribute this program without offering the source code. Hosting
226 | a web service that utilizes livelook is distrubtion.**
227 | 


--------------------------------------------------------------------------------
/doc/SoulseekProtocol – Museek+_files/babel.js:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * Babel JavaScript Support
  3 |  *
  4 |  * Copyright (C) 2008 Edgewall Software
  5 |  * All rights reserved.
  6 |  *
  7 |  * This software is licensed as described in the file COPYING, which
  8 |  * you should have received as part of this distribution. The terms
  9 |  * are also available at http://babel.edgewall.org/wiki/License.
 10 |  *
 11 |  * This software consists of voluntary contributions made by many
 12 |  * individuals. For the exact contribution history, see the revision
 13 |  * history and logs, available at http://babel.edgewall.org/log/.
 14 |  */
 15 | 
 16 | /**
 17 |  * A simple module that provides a gettext like translation interface.
 18 |  * The catalog passed to load() must be a object conforming to this
 19 |  * interface::
 20 |  *
 21 |  *    {
 22 |  *      messages:     an object of {msgid: translations} items where
 23 |  *                    translations is an array of messages or a single
 24 |  *                    string if the message is not pluralizable.
 25 |  *      plural_expr:  the plural expression for the language.
 26 |  *      locale:       the identifier for this locale.
 27 |  *      domain:       the name of the domain.
 28 |  *    }
 29 |  *
 30 |  * Missing elements in the object are ignored.
 31 |  *
 32 |  * Typical usage::
 33 |  *
 34 |  *    var translations = babel.Translations.load(...).install();
 35 |  */
 36 | var babel = new function() {
 37 | 
 38 |   var defaultPluralExpr = function(n) { return n == 1 ? 0 : 1; };
 39 |   var formatRegex = /%(?:(?:\(([^\)]+)\))?([disr])|%)/g;
 40 |   var translations = {};
 41 |   var merged;
 42 | 
 43 |   /**
 44 |    * A translations object implementing the gettext interface
 45 |    */
 46 |   var Translations = this.Translations = function(locale, domain) {
 47 |     this.messages = {};
 48 |     this.locale = locale || 'unknown';
 49 |     this.domain = domain || 'messages';
 50 |     this.pluralexpr = defaultPluralExpr;
 51 |   };
 52 | 
 53 |   /**
 54 |    * Create a new translations object from the catalog and return it.
 55 |    * See the babel-module comment for more details.
 56 |    */
 57 |   Translations.load = function(catalog) {
 58 |     var rv = new Translations();
 59 |     rv.load(catalog);
 60 |     translations[rv.domain] = rv;
 61 |     merged.load(catalog);
 62 |     return rv;
 63 |   };
 64 | 
 65 |   /**
 66 |    * Get a Translations instance from the loaded translations. If the
 67 |    * specified domain doesn't exist, returns a dummy Translations
 68 |    * instance.
 69 |    */
 70 |   Translations.get = function(domain) {
 71 |     return translations[domain] || (new Translations({domain: domain}));
 72 |   };
 73 | 
 74 |   Translations.prototype = {
 75 |     /**
 76 |      * translate a single string
 77 |      *
 78 |      * If extra parameters are given, use them to fill the format
 79 |      * specified by the string.
 80 |      */
 81 |     gettext: function(string) {
 82 |       var translated = this.messages[string];
 83 |       if (typeof translated == 'undefined')
 84 |         translated = string;
 85 |       else if (typeof translated != 'string')
 86 |         translated = translated[0];
 87 |       if (arguments.length > 1) {
 88 |         arguments[0] = translated;
 89 |         return babel.format.apply(this, arguments);
 90 |       }
 91 |       return translated;
 92 |     },
 93 | 
 94 |     /**
 95 |      * translate a pluralizable string
 96 |      *
 97 |      * If extra parameters are given, use them to fill the format
 98 |      * specified by the string.
 99 |      */
100 |     ngettext: function(singular, plural, n) {
101 |       var translated = this.messages[singular];
102 |       if (typeof translated == 'undefined')
103 |         translated = (n == 1) ? singular : plural;
104 |       else
105 |         translated = translated[this.pluralexpr(n)];
106 |       if (arguments.length > 3) {
107 |         var format_args = Array.prototype.slice.call(arguments, 3);
108 |         format_args.unshift(translated);
109 |         return babel.format.apply(this, format_args)
110 |       }
111 |       return translated;
112 |     },
113 | 
114 |     /**
115 |      * Install this translation document wide.  After this call, there are
116 |      * three new methods on the window object: _, gettext and ngettext
117 |      */
118 |     install: function() {
119 |       window._ = window.gettext = function() {
120 |         return merged.gettext.apply(merged, arguments);
121 |       };
122 |       window.ngettext = function(singular, plural, n) {
123 |         return merged.ngettext.apply(merged, arguments);
124 |       };
125 |       return this;
126 |     },
127 | 
128 |     /**
129 |      * Works like Translations.load but updates the instance rather
130 |      * then creating a new one.
131 |      */
132 |     load: function(catalog) {
133 |       if (catalog.messages)
134 |         this.update(catalog.messages)
135 |       if (catalog.plural_expr)
136 |         this.setPluralExpr(catalog.plural_expr);
137 |       if (catalog.locale)
138 |         this.locale = catalog.locale;
139 |       if (catalog.domain)
140 |         this.domain = catalog.domain;
141 |       return this;
142 |     },
143 | 
144 |     /**
145 |      * Updates the translations with the object of messages.
146 |      */
147 |     update: function(mapping) {
148 |       for (var key in mapping)
149 |         if (mapping.hasOwnProperty(key))
150 |           this.messages[key] = mapping[key];
151 |       return this;
152 |     },
153 | 
154 |     /**
155 |      * Sets the plural expression
156 |      */
157 |     setPluralExpr: function(expr) {
158 |       this.pluralexpr = new Function('n', 'return +(' + expr + ')');
159 |       return this;
160 |     }
161 |   };
162 | 
163 |   merged = new Translations({});
164 | 
165 |   /**
166 |    * Translate a single string in the specified domain.
167 |    *
168 |    * If extra parameters are given, use them to fill the format
169 |    * specified by the string.
170 |    */
171 |   window.dgettext = this.dgettext = function(domain, string) {
172 |     var rv = translations[domain];
173 |     var args = Array.prototype.slice.call(arguments, 1);
174 |     if (typeof rv != 'undefined')
175 |       return rv.gettext.apply(rv, args);
176 |     if (arguments.length > 1)
177 |       return babel.format.apply(this, args);
178 |     return string;
179 |   };
180 | 
181 |   /**
182 |    * Translate a pluralizable string in the specified domain.
183 |    *
184 |    * If extra parameters are given, use them to fill the format
185 |    * specified by the string.
186 |    */
187 |   window.dngettext = this.dngettext = function(domain, singular, plural, n) {
188 |     var rv = translations[domain];
189 |     if (typeof rv != 'undefined') {
190 |       var args = Array.prototype.slice.call(arguments, 1);
191 |       return rv.ngettext.apply(rv, args);
192 |     }
193 |     if (arguments.length > 4) {
194 |       var args = Array.prototype.slice.call(arguments, 4);
195 |       args.unshift(singular);
196 |       return babel.format.apply(this, format_args)
197 |     }
198 |     return (n == 1) ? singular : plural;
199 |   };
200 | 
201 |   /**
202 |    * A python inspired string formatting function.  Supports named and
203 |    * positional placeholders and "s", "d" and "i" as type characters
204 |    * without any formatting specifications.
205 |    *
206 |    * Examples::
207 |    *
208 |    *    babel.format(_('Hello %s'), name)
209 |    *    babel.format(_('Progress: %(percent)s%%'), {percent: 100})
210 |    */
211 |   this.format = function() {
212 |     var arg, string = arguments[0], idx = 0;
213 |     if (arguments.length == 1)
214 |       return string;
215 |     else if (arguments.length == 2 && typeof arguments[1] == 'object')
216 |       arg = arguments[1];
217 |     else {
218 |       arg = [];
219 |       for (var i = 1, n = arguments.length; i != n; ++i)
220 |         arg[i - 1] = arguments[i];
221 |     }
222 |     return string.replace(formatRegex, function(all, name, type) {
223 |       if (all == '%%') return '%';
224 |       var value = arg[name || idx++];
225 |       return (type == 'i' || type == 'd') ? +value : value;
226 |     });
227 |   }
228 | 
229 | };
230 | 


--------------------------------------------------------------------------------
/doc/SoulseekProtocol – Museek+_files/folding.js:
--------------------------------------------------------------------------------
 1 | (function($){
 2 | 
 3 |   $.fn.enableFolding = function(autofold, snap) {
 4 |     var fragId = document.location.hash;
 5 |     if (fragId && /^#no\d+$/.test(fragId))
 6 |       fragId = parseInt(fragId.substr(3));
 7 |     if (snap == undefined)
 8 |       snap = false;
 9 | 
10 |     var count = 1;
11 |     return this.each(function() {
12 |       // Use first child <a> as a trigger, or generate a trigger from the text
13 |       var trigger = $(this).children("a").eq(0);
14 |       if (trigger.length == 0) {
15 |         trigger = $("<a" + (snap? " id='no" + count + "'": "")
16 |             + " href='#no" + count + "'></a>");
17 |         trigger.html($(this).html());
18 |         $(this).text("");
19 |         $(this).append(trigger);
20 |       }
21 | 
22 |       trigger.click(function() {
23 |         var div = $(this.parentNode.parentNode).toggleClass("collapsed");
24 |         return snap && !div.hasClass("collapsed");
25 |       });
26 |       if (autofold && (count != fragId))
27 |         trigger.parents().eq(1).addClass("collapsed");
28 |       count++;
29 |     });
30 |   }
31 | 
32 |   /** Enable columns of a table to be hidden by clicking on the column header.
33 |    *
34 |    * +------------------+------+---- ... ---+---------------------+
35 |    * |column_headers[0] | ...  |            | column_headers[k-1] | <- c_h_row
36 |    * +==================+======+==== ... ===+=====================+
37 |    * | row_headers[0]   | row_headers[1]    | row_headers[1*k-1]  | <- rows[0]
38 |    * | row_headers[k]   | row_headers[k+1]  | row_headers[2*k-1]  | <- rows[1]
39 |    * ...
40 |    */
41 |   $.fn.enableCollapsibleColumns = function(recovery_area) {
42 |     // column headers
43 |     var c_h_row = $('thead tr', this);
44 |     var column_headers = $('th', c_h_row).not(recovery_area);
45 |     var k = column_headers.length;
46 |     // row headers
47 |     var tbody = $('tbody', this);
48 |     var row_headers = $('th', tbody);
49 |     var rows = $('tr', tbody);
50 |     var n = row_headers.length / k;
51 | 
52 |     // add a 'hide' callback to each column header
53 |     column_headers.each(function(j) {
54 |         function hide() {
55 |           // remove and save column j
56 |           var th = $(this);
57 |           th.css('display', 'none');
58 |           for ( var i = 0; i < n; i++ )
59 |             row_headers.eq(i*k+j).css('display', 'none');
60 |           // create a recovery button and its "show" callback
61 |           recovery_area.prepend($("<span></span>").addClass("recover")
62 |             .text(_("Show %(title)s", {title: th.text()}))
63 |             .click(function() {
64 |               $(this).remove();
65 |               th.show();
66 |               for (var i = 0; i < n; i++)
67 |                 row_headers.eq(i*k+j).css('display', 'table-cell');
68 |             })
69 |           );
70 |         };
71 |         $(this).click(hide)
72 |           .css('cursor', 'pointer')
73 |           .attr('title', _("%(title)s (click to hide column)",
74 |                            {title: $(this).attr('title')}));
75 |       });
76 |   }
77 | 
78 | })(jQuery);
79 | 


--------------------------------------------------------------------------------
/doc/SoulseekProtocol – Museek+_files/main.css:
--------------------------------------------------------------------------------
  1 | /* Link styles */
  2 | a:hover, a:link, a:active, a:visited {
  3 |   color: #5785ed;
  4 | }
  5 | /* Link styles */
  6 | 
  7 | 
  8 | /* Styles for the roadmap view */
  9 | .milestone .info h2 em { 
 10 |   color: #57c1ed; 
 11 | }
 12 | /* Styles for the roadmap view */
 13 | 
 14 | 
 15 | /* Timeline */
 16 | dt em {
 17 |   color: #5785ed;
 18 | }
 19 | /* Timeline */
 20 | 
 21 | 
 22 | /* Browser */
 23 | h1 :link, h1 :visited {
 24 |   color: #57c1ed;
 25 | }
 26 | /* Browser */
 27 | 
 28 | 
 29 | /* Forms */
 30 | input[type=button]:hover, input[type=submit]:hover, input[type=reset]:hover {
 31 |    background: #57c1ed;
 32 | }
 33 | /* Forms */
 34 | 
 35 | 
 36 | /* Left menu */
 37 | #menu_left {
 38 |   width: 135px;
 39 |   position: absolute;
 40 |   float: left;
 41 |   top: 126px;
 42 |   margin: 0px;
 43 |   padding: 50px 10px 50px 10px;
 44 |   color: #57c1ed;
 45 |   border: black 1px solid;
 46 |   border-top: none;
 47 |   background-color: #f7f7f7;
 48 |   z-index: 900;
 49 | }
 50 | #menu_left li {
 51 |   font-weight: bold;
 52 | }
 53 | #menu_left a:link, a:visited {
 54 |   color: #5785ed;
 55 | }
 56 | #menu_left ul li ul li {
 57 |   font-weight: normal;
 58 | }
 59 | #menu_left ul {
 60 |   list-style: none;
 61 |   margin: 0;
 62 |   padding: 0;
 63 | }
 64 | #menu_left ul li {
 65 |   margin: 0;
 66 |   padding: 4px;
 67 | }
 68 | /* Left menu */
 69 | 
 70 | 
 71 | /* Banner */
 72 | #header {
 73 |   padding: 0px;
 74 |   margin: 10px 0px 0px 10px;
 75 | }
 76 | /* Banner */
 77 | 
 78 | 
 79 | /* Search box */
 80 | #search {
 81 |   position: absolute;
 82 |   top: 40px;
 83 |   right: 15px;
 84 |   margin: 0px;
 85 |   padding: 0px;
 86 | }
 87 | /* Search box */
 88 | 
 89 | 
 90 | /* Meta nav */
 91 | #metanav {
 92 |   position: absolute;
 93 |   top: 70px;
 94 |   right: 10px;
 95 |   margin: 0px;
 96 |   padding: 0px;
 97 | }
 98 | /* Meta nav */
 99 | 
100 | 
101 | /* Main nav */
102 | #mainnav {
103 |   background: #f7f7f7;
104 |   position: absolute;
105 |   top: 100px;
106 |   right: 2%px;
107 |   width: 98%;
108 |   margin: 0px;
109 |   height: 25px;
110 |   padding: 0px;
111 | }
112 | #mainnav ul {
113 |   display: table;
114 |   float: right;
115 |   margin: 0px;
116 |   padding: 0px;
117 | } 
118 | #mainnav li {
119 |   display:table-cell;
120 |   margin: 0px;
121 |   padding: 0px;
122 | }
123 | #mainnav ul li a {
124 |   position: relative;
125 |   float: right;
126 |   height: 21px;
127 |   padding: 0px;
128 |   margin: 0px;
129 | }
130 | #mainnav .active :link, #mainnav .active :visited {
131 |   background: #57c1ed;
132 | }
133 | /* Main nav */
134 | 
135 | 
136 | /* Ctx nav */
137 | #ctxtnav {
138 |   margin-top: 7.0em;
139 | }
140 | /* Ctx nav */
141 | 
142 | 
143 | /* Main page */
144 | *>#content {
145 |   padding: 0;
146 |   margin: 15px 15px 0px 180px;
147 |   text-align: left;
148 |   min-height: 770px;
149 | }
150 | * html #content {
151 |   padding: 0;
152 |   margin: 15px 15px 0px 180px;
153 |   text-align: left;
154 |   height: 770px;
155 | }
156 | /* Main page */
157 | 
158 | 
159 | /* Need by Doxygen plugin */
160 | .tabs{
161 |   margin: 85px 0px 0px 0px;
162 | }
163 | /* Need by Doxygen plugin */
164 | 
165 | 
166 | /* NewsFlash Plugin */
167 | div.newsflash {
168 |   color: black;
169 |   background: #f7f7f7;
170 |   border: solid 2px #43eeff;
171 | }
172 | /* NewsFlash Plugin */
173 | 


--------------------------------------------------------------------------------
/doc/SoulseekProtocol – Museek+_files/museek_banner_github.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/misterhat/livelook/630241218e6dbd6db19779bbf6e95c1ffe6a8b38/doc/SoulseekProtocol – Museek+_files/museek_banner_github.png


--------------------------------------------------------------------------------
/doc/SoulseekProtocol – Museek+_files/search.js:
--------------------------------------------------------------------------------
  1 | (function($){
  2 | 
  3 |   /* Adapted from http://www.kryogenix.org/code/browser/searchhi/ */
  4 |   $.fn.highlightText = function(text, className, caseSensitive) {
  5 |     function highlight(node) {
  6 |       if (node.nodeType == 3) { // Node.TEXT_NODE
  7 |         var val = node.nodeValue;
  8 |         var pos = (caseSensitive ? val : val.toLowerCase()).indexOf(text);
  9 |         if (pos >= 0 && !$(node.parentNode).hasClass(className)) {
 10 |           var span = document.createElement("span");
 11 |           span.className = className;
 12 |           var txt = document.createTextNode(val.substr(pos, text.length));
 13 |           span.appendChild(txt);
 14 |           node.parentNode.insertBefore(span, node.parentNode.insertBefore(
 15 |             document.createTextNode(val.substr(pos + text.length)),
 16 |               node.nextSibling));
 17 |           node.nodeValue = val.substr(0, pos);
 18 |         }
 19 |       } else if (!$(node).is("button, select, textarea")) {
 20 |         $.each(node.childNodes, function() { highlight(this) });
 21 |       }
 22 |     }
 23 |     return this.each(function() { highlight(this) });
 24 |   }
 25 | 
 26 |   $(document).ready(function() {
 27 |     $("p.filters").on("click", ":checkbox, :checkbox + label",
 28 |       function(event) {
 29 |         if (!event.metaKey && !event.altKey)
 30 |           return;
 31 |         var clicked = this.tagName === "LABEL" ?
 32 |                       document.getElementById(this.htmlFor) : this;
 33 |         var $clicked = $(clicked);
 34 |         $clicked.prop("checked", true);
 35 |         $clicked.siblings(":checkbox").prop("checked", false);
 36 |         if (this.tagName === "LABEL") {
 37 |           return false;
 38 |         }
 39 |       });
 40 | 
 41 |     var elems = $(".searchable");
 42 |     if (!elems.length) return;
 43 | 
 44 |     function getSearchTerms(url) {
 45 |       if (url.indexOf("?") == -1) return [];
 46 |       var params = url.substr(url.indexOf("?") + 1).split("&");
 47 |       for (var p in params) {
 48 |         var param = params[p].split("=");
 49 |         if (param.length < 2) continue;
 50 |         if (param[0] == "q" || param[0] == "p") {// q= for Google, p= for Yahoo
 51 |           var query = decodeURIComponent(param[1].replace(/\+/g, " "));
 52 |           if (query[0] == "!") query = query.slice(1);
 53 |           var terms = [];
 54 |           $.each(query.split(/(".*?"|'.*?'|\s+)/), function() {
 55 |             if (terms.length < 10) {
 56 |               term = this.replace(/^\s+$/, "")
 57 |                          .replace(/^['"]/, "")
 58 |                          .replace(/['"]$/, "");
 59 |               if (term.length >= 3)
 60 |                 terms.push(term);
 61 |             }
 62 |           });
 63 |           return terms;
 64 |         }
 65 |       }
 66 |       return [];
 67 |     }
 68 | 
 69 |     var terms = getSearchTerms(document.URL);
 70 |     if (!terms.length) terms = getSearchTerms(document.referrer);
 71 |     if (terms.length) {
 72 |       $.each(terms, function(idx) {
 73 |         elems.highlightText(this.toLowerCase(), "searchword" + (idx % 5));
 74 |       });
 75 |     } else {
 76 |       function scrollToHashSearchMatch() {
 77 |         var h = window.location.hash;
 78 |         var direction = h[1];
 79 |         var case_insensitive = h.match(/\/i$/);
 80 |         if (direction == '/' || direction == '?') {
 81 |           var hterm = h.substr(2);
 82 |           if (case_insensitive)
 83 |             hterm = hterm.substr(0, hterm.length - 2).toLowerCase();
 84 |           $('.searchword0').each(function() {
 85 |             $(this).after($(this).html()).remove();
 86 |           });
 87 |           elems.highlightText(hterm, "searchword0", !case_insensitive);
 88 |           var hmatches = $('.searchword0');
 89 |           if (direction == '?')
 90 |             hmatches = hmatches.last();
 91 |           hmatches.first().each(function() {
 92 |             var offset = $(this).offset().top;
 93 |             window.scrollTo(0, offset);
 94 |           });
 95 |         }
 96 |       }
 97 |       window.onhashchange = scrollToHashSearchMatch;
 98 |       scrollToHashSearchMatch();
 99 |     }
100 |   });
101 | 
102 | })(jQuery);
103 | 


--------------------------------------------------------------------------------
/doc/SoulseekProtocol – Museek+_files/trac.css:
--------------------------------------------------------------------------------
  1 | /* -*- coding: utf-8 -*- */
  2 | html { overflow-y: scroll }
  3 | body {
  4 |  background: #fff;
  5 |  color: #000;
  6 |  margin: 10px;
  7 |  padding: 0;
  8 | }
  9 | body, th, tr {
 10 |  font: normal 13px Verdana,Arial,'Bitstream Vera Sans',Helvetica,sans-serif;
 11 | }
 12 | h1, h2, h3, h4 {
 13 |  font-family: Arial,Verdana,'Bitstream Vera Sans',Helvetica,sans-serif;
 14 |  font-weight: bold;
 15 |  letter-spacing: -0.018em;
 16 |  page-break-after: avoid;
 17 | }
 18 | h1 { font-size: 19px; margin: .15em 1em 0.5em 0 }
 19 | h2 { font-size: 16px }
 20 | h3 { font-size: 14px }
 21 | hr { border: none;  border-top: 1px solid #ccb; margin: 2em 0 }
 22 | address { font-style: normal }
 23 | img { border: none }
 24 | 
 25 | .underline { text-decoration: underline }
 26 | ol.loweralpha { list-style-type: lower-alpha }
 27 | ol.upperalpha { list-style-type: upper-alpha }
 28 | ol.lowerroman { list-style-type: lower-roman }
 29 | ol.upperroman { list-style-type: upper-roman }
 30 | ol.arabic     { list-style-type: decimal }
 31 | 
 32 | /* Link styles */
 33 | :link, :visited {
 34 |  text-decoration: none;
 35 |  color: #b00;
 36 |  border-bottom: 1px dotted #bbb;
 37 | }
 38 | :link:hover, :visited:hover { background-color: #eee; color: #555 }
 39 | h1 :link, h1 :visited ,h2 :link, h2 :visited, h3 :link, h3 :visited,
 40 | h4 :link, h4 :visited, h5 :link, h5 :visited, h6 :link, h6 :visited {
 41 |  color: inherit;
 42 | }
 43 | 
 44 | /* Heading anchors */
 45 | .anchor:link, .anchor:visited {
 46 |  border: none;
 47 |  color: #d7d7d7;
 48 |  font-size: .8em;
 49 |  vertical-align: text-top;
 50 | }
 51 | * > .anchor:link, * > .anchor:visited {
 52 |  visibility: hidden;
 53 | }
 54 | h1:hover .anchor, h2:hover .anchor, h3:hover .anchor,
 55 | h4:hover .anchor, h5:hover .anchor, h6:hover .anchor,
 56 | span:hover .anchor {
 57 |  visibility: visible;
 58 | }
 59 | 
 60 | h1:target, h2:target, h3:target, h4:target, h5:target, h6:target,
 61 | span:target {
 62 |  background: #ffb;
 63 |  box-shadow: .1em .1em .4em .1em #DDA;
 64 |  border-radius: .2em;
 65 | }
 66 | 
 67 | @media screen {
 68 |  a.ext-link .icon {
 69 |   background: url(../extlink.gif) left center no-repeat;
 70 |   padding-left: 15px;
 71 |  }
 72 |  a.mail-link .icon {
 73 |   background: url(../envelope.png) left center no-repeat;
 74 |   padding-left: 16px;
 75 |  }
 76 |  a.trac-rawlink, a.trac-ziplink {
 77 |   background: url('../download.png') right center no-repeat;
 78 |   padding-right: 16px;
 79 |   border-bottom: none;
 80 |  }
 81 | }
 82 | 
 83 | /* Forms */
 84 | input, textarea, select, .trac-button { margin: 2px }
 85 | /* Avoid respect to system font settings for controls on Firefox, #11607 */
 86 | input, select, button {
 87 |  font-family: Arial,Verdana,'Bitstream Vera Sans',Helvetica,sans-serif;
 88 |  font-size: 100%;
 89 | }
 90 | /* Avoid to inherit white-space of its parent element for IE 11, #11376 */
 91 | textarea { white-space: pre-wrap }
 92 | input, select, .trac-button { vertical-align: middle }
 93 | input[type=button], input[type=submit], input[type=reset], button {
 94 |  *overflow: visible; /* Workaround too much margin on button in IE7 */
 95 | }
 96 | input[type=button], input[type=submit], input[type=reset], .trac-button {
 97 |  background: #eee;
 98 |  color: #222;
 99 |  border: 1px outset #eee;
100 |  border-radius: .3em;
101 |  box-shadow: .1em .1em .4em 0 #888;
102 |  padding: .1em .5em .2em;
103 |  text-shadow: .04em .04em #ddd;
104 |  cursor: pointer;
105 | }
106 | input[type=button]:hover, input[type=submit]:hover, input[type=reset]:hover,
107 | .trac-button:hover {
108 |  background: #f6f6f6;
109 |  box-shadow: .1em .1em .6em 0 #999;
110 |  text-shadow: .04em .04em #fcfcfc;
111 | }
112 | input[type=button]:active, input[type=submit]:active, input[type=reset]:active,
113 | .trac-button:active, .inlinebuttons a:active {
114 |  position: relative;
115 |  top: .1em;
116 |  left: .1em;
117 | }
118 | input[type=button][disabled], input[type=submit][disabled],
119 | input[type=reset][disabled], .trac-button[disabled] {
120 |  background: #f6f6f6;
121 |  border-style: solid;
122 |  color: #999;
123 | }
124 | input[type=text], input.textwidget, textarea {
125 |  border: 1px solid #d7d7d7;
126 |  border-radius: .3em;
127 | }
128 | input[type=text], input.textwidget { padding: .25em .5em }
129 | input[type=text]:focus, input.textwidget:focus, textarea:focus {
130 |  border: 1px solid #886;
131 | }
132 | option { border-bottom: 1px dotted #d7d7d7 }
133 | fieldset {
134 |  border: 1px solid #d7d7d7;
135 |  border-radius: .4em;
136 |  margin: 1em 0;
137 |  background: #F7F7F0;
138 |  box-shadow: .1em .1em 1em 0 #E7E7E7 inset;
139 |  padding: 1em;
140 | }
141 | p.hint, span.hint, span.trac-datetimehint {
142 |  color: #666;
143 |  font-size: 85%;
144 |  font-style: italic;
145 |  margin: .5em 0;
146 |  padding-left: 1em;
147 | }
148 | span.hint { vertical-align: middle; }
149 | p.help { color: #666; font-size: 90%; margin: 1em .5em .5em; }
150 | legend {
151 |  color: #999;
152 |  margin-left: .6em;
153 |  padding: 0 .25em;
154 |  font-size: 90%;
155 |  font-weight: bold;
156 | }
157 | label.disabled, .disabled span.hint, .disabled p.help, .disabled legend,
158 | .disabled input, .disabled select, .readonly span.hint, .readonly p.help {
159 |  color: #d7d7d7
160 | }
161 | .buttons { margin: .5em .5em .5em 0 }
162 | .buttons form, .buttons form div { display: inline }
163 | .buttons input { margin: 1em .5em .1em 0 }
164 | 
165 | .inlinebuttons input,
166 | .inlinebuttons .trac-button,
167 | .inlinebuttons a {
168 |  border: 1px solid #ddd;
169 |  border-radius: 1em;
170 |  height: 1.6em;
171 |  padding: 0 .4em .1em;
172 |  font-size: 70%;
173 |  box-shadow: none;
174 |  margin: 0 .1em .1em;
175 |  background: none;
176 |  color: #808080;
177 |  cursor: pointer;
178 | }
179 | .uisymbols .inlinebuttons input[type=button],
180 | .uisymbols .inlinebuttons input[type=submit],
181 | .uisymbols .inlinebuttons .trac-button,
182 | .uisymbols .inlinebuttons a {
183 |  font-size: 100%;
184 | }
185 | .inlinebuttons input[type=button]:hover,
186 | .inlinebuttons input[type=submit]:hover,
187 | .inlinebuttons .trac-button:hover,
188 | .inlinebuttons a:hover {
189 |  background: #f6f6f6;
190 |  color: #333;
191 |  text-shadow: .04em .04em #fcfcfc;
192 |  box-shadow: .1em .1em .6em 0 #999;
193 | }
194 | input[type=button].trac-delete,
195 | input[type=submit].trac-delete,
196 | .trac-button.trac-delete {
197 |  color: #d31313;
198 | }
199 | input[type=button].trac-delete:hover,
200 | input[type=submit].trac-delete:hover,
201 | .trac-button.trac-delete:hover {
202 |  color: #e31313;
203 | }
204 | textarea.trac-fullwidth, input.trac-fullwidth, button.trac-fullwidth {
205 |  -moz-box-sizing: border-box;
206 |  box-sizing: border-box;
207 |  margin-left: 0;
208 |  margin-right: 0;
209 |  width: 100%;
210 | }
211 | textarea.trac-fullwidth { padding: 2px; }
212 | /* Resource edit forms (detailed view) */
213 | form.mod { margin: 1em 0 }
214 | form.mod .field { margin: .5em 0; }
215 | form.mod .field.description { margin-top: 1em; }
216 | form.mod .field label { padding-left: .2em }
217 | form.mod #changeinfo .field { margin: 0.25em 0 0.75em 0 }
218 | form.mod #changeinfo .options { padding: 0 0 0.5em 1em }
219 | 
220 | /* Header */
221 | #header hr { display: none }
222 | #header h1 { margin: 1.5em 0 -1.5em; padding: 0 }
223 | #header img { border: none; margin: 0 0 -3em }
224 | #header :link, #header :visited, #header :link:hover, #header :visited:hover {
225 |  background: transparent;
226 |  color: #555;
227 |  margin-bottom: 2px;
228 |  border: none;
229 |  padding: 0;
230 | }
231 | #header h1 :link:hover, #header h1 :visited:hover { color: #000 }
232 | 
233 | /* Quick search */
234 | #search {
235 |  clear: both;
236 |  font-size: 10px;
237 |  height: 2.2em;
238 |  margin: 0 0 1em;
239 |  text-align: right;
240 | }
241 | #search input { font-size: 10px }
242 | #search label { display: none }
243 | 
244 | /* Navigation */
245 | .nav h2, .nav hr { display: none }
246 | .nav ul {
247 |  font-size: 10px;
248 |  list-style: none;
249 |  margin: 0;
250 |  padding: 0;
251 |  text-align: right;
252 | }
253 | .nav li {
254 |  border-right: 1px solid #d7d7d7;
255 |  display: inline-block;
256 |  padding: 0 .75em;
257 |  white-space: nowrap;
258 |  /* IE7 hack to make inline-block effective on block element */
259 |  zoom: 1;
260 |  *display: inline;
261 | }
262 | .nav li.last { border-right: none }
263 | 
264 | /* Meta navigation bar */
265 | #metanav {
266 |  padding-top: .3em;
267 | }
268 | #metanav form.trac-logout {
269 |  display: inline;
270 |  margin: 0;
271 |  padding: 0;
272 | }
273 | #metanav form.trac-logout button {
274 |  margin: 0;
275 |  padding: 0;
276 |  border: 0;
277 |  outline: 0;
278 |  background: transparent;
279 |  font-family: inherit;
280 |  font-size: 100%;
281 |  color: #b00;
282 |  border-bottom: 1px dotted #bbb;
283 |  cursor: pointer;
284 | }
285 | #metanav form.trac-logout button::-moz-focus-inner { border: 0; padding: 0 }
286 | #metanav form.trac-logout button:hover { background-color: #eee; color: #555 }
287 | #metanav form.trac-logout button:active { position: static }
288 | 
289 | /* Main navigation bar */
290 | #mainnav {
291 |  font: normal 10px verdana,'Bitstream Vera Sans',helvetica,arial,sans-serif;
292 |  box-shadow: 0 .5em 1.5em #eee;
293 |  border: 1px solid #e4e4e4;
294 |  border-radius: .5em;
295 |  margin: .66em 0 .33em;
296 | }
297 | #mainnav li {
298 |  background: white url(../topbar_gradient.png) 0 0;
299 |  border: 1px solid #e4e4e4;
300 |  margin: -1px .3em 0 -.4em;
301 |  padding: .3em 0;
302 | }
303 | 
304 | #mainnav .first, #mainnav .first :link {
305 |  border-top-left-radius: .5em;
306 |  border-bottom-left-radius: .5em;
307 | }
308 | #mainnav .last, #mainnav .last :link {
309 |  border-top-right-radius: .5em;
310 |  border-bottom-right-radius: .5em;
311 |  margin-right: 0;
312 | }
313 | 
314 | #mainnav :link, #mainnav :visited {
315 |  border-bottom: none;
316 |  box-shadow: 0 .1em .3em 0 #999;
317 |  color: #000;
318 |  padding: .3em 20px;
319 | }
320 | 
321 | #mainnav li:hover {
322 |  border: 1px solid #666;
323 | }
324 | #mainnav :link:hover, #mainnav :visited:hover {
325 |  background: #000 url(../topbar_gradient2.png) 0 0 repeat-x;
326 |  color: #eee;
327 |  box-shadow: 0 .1em .6em 0 #666;
328 | }
329 | 
330 | #mainnav .active {
331 |  border: 1px solid #666;
332 | }
333 | #mainnav .active :link, #mainnav .active :visited {
334 |  background: #000 url(../topbar_gradient2.png) 0 0 repeat-x;
335 |  color: #eee;
336 |  text-shadow: 1px 0 #eee;
337 | }
338 | 
339 | /* Context-dependent navigation links */
340 | #ctxtnav {
341 |  min-height: 1em;
342 |  padding: .4em 0;
343 | }
344 | #ctxtnav li ul {
345 |  background: #f7f7f7;
346 |  color: #ccc;
347 |  border: 1px solid;
348 |  padding: 0;
349 |  display: inline;
350 |  margin: 0;
351 | }
352 | #ctxtnav li li { padding: 0; }
353 | #ctxtnav li li :link, #ctxtnav li li :visited { padding: 0 1em }
354 | #ctxtnav li li :link:hover, #ctxtnav li li :visited:hover {
355 |  background: #bba;
356 |  color: #fff;
357 | }
358 | 
359 | .trac-nav, .trac-topnav {
360 |  float: right;
361 |  font-size: 80%;
362 | }
363 | .trac-topnav {
364 |  margin-top: 14px;
365 | }
366 | 
367 | /* Alternate links */
368 | #altlinks {
369 |  clear: both;
370 |  margin-top: .4em;
371 |  text-align: center;
372 | }
373 | #altlinks h3 { font-size: 12px; letter-spacing: normal; margin: 0 }
374 | #altlinks ul { list-style: none; margin: 0; padding: 0 }
375 | #altlinks li {
376 |  border-right: 1px solid #d7d7d7;
377 |  display: inline;
378 |  font-size: 11px;
379 |  line-height: 1.5;
380 |  padding: 0 1em;
381 |  white-space: nowrap;
382 | }
383 | #altlinks li.last { border-right: none }
384 | #altlinks li :link, #altlinks li :visited {
385 |  background-repeat: no-repeat;
386 |  color: #666;
387 |  border: none;
388 |  padding: 0 0 2px;
389 | }
390 | #altlinks li a.ics {
391 |  background: url(../ics.png) left center no-repeat;
392 |  padding-left: 22px;
393 | }
394 | #altlinks li a.rss {
395 |  background: url(../feed.png) left center no-repeat;
396 |  padding-left: 20px;
397 | }
398 | 
399 | /* Footer */
400 | #footer {
401 |  clear: both;
402 |  color: #bbb;
403 |  font-size: 10px;
404 |  height: 31px;
405 |  padding: .25em 0;
406 | }
407 | #footer :link, #footer :visited { color: #bbb; }
408 | #footer hr { display: none }
409 | #footer #tracpowered { border: 0; float: left }
410 | #footer #tracpowered:hover { background: transparent }
411 | #footer p { margin: 0 }
412 | #footer p.left {
413 |  float: left;
414 |  margin-left: 1em;
415 |  padding: 0 1em;
416 |  border-left: 1px solid #d7d7d7;
417 |  border-right: 1px solid #d7d7d7;
418 | }
419 | #footer p.right {
420 |  float: right;
421 |  text-align: right;
422 | }
423 | 
424 | /* Container for all the elements in the page, usually single child of the body element */
425 | #content {
426 |  position: relative; /* reference for absolute positioning of children */
427 | }
428 | 
429 | /* Information content */
430 | div.trac-content {
431 |  padding: .5em 1em;
432 |  margin: .3em auto;
433 |  border: 1px solid #e4e4e4;
434 |  border-radius: .5em;
435 |  box-shadow: .2em .3em 1.5em #eee;
436 | }
437 | 
438 | /* Author info */
439 | .trac-author-anonymous, .trac-author-none {
440 |  font-style: italic;
441 | }
442 | .trac-author-user {
443 |  font-weight: bold;
444 |  color: #666;
445 | }
446 | 
447 | /* Help links */
448 | .uinohelp #help { display: none }
449 | #help {
450 |  clear: both;
451 |  color: #999;
452 |  font-size: 90%;
453 |  margin: 1em;
454 |  text-align: right;
455 | }
456 | #help :link, #help :visited { cursor: help }
457 | #help hr { display: none }
458 | 
459 | /* Datepicker hints */
460 | .trac-nodatetimehint .trac-datetimehint { display: none }
461 | 
462 | /* Section folding */
463 | .foldable :link, .foldable :visited {
464 |  background: url(../expanded.png) 4px 50% no-repeat;
465 |  border: none;
466 |  border-radius: .3em;
467 |  box-shadow: .1em .1em .3em 0 #bbb;
468 |  color: #222;
469 |  text-shadow: .04em .04em #fcfcfc;
470 |  padding: .3em .5em .3em 20px;
471 | }
472 | .foldable :link:hover, .foldable :visited:hover { background-color: transparent }
473 | .collapsed > .foldable :link, .collapsed > .foldable :visited {
474 |  background-image: url(../collapsed.png);
475 | }
476 | .collapsed > div, .collapsed > table, .collapsed > ul, .collapsed > dl { display: none }
477 | fieldset > legend.foldable :link, fieldset > legend.foldable :visited {
478 |  color: #666;
479 |  font-size: 110%;
480 |  text-shadow: .04em .04em #ddd;
481 | }
482 | .collapsed legend.foldable { background: white }
483 | 
484 | .expander {
485 |  background: url(../expander_normal.png) 0 50% no-repeat;
486 |  cursor: pointer;
487 |  padding-left: 8px;
488 |  margin-left: 4px;
489 | }
490 | .expander:hover {
491 |  background: url(../expander_normal_hover.png) 0 50% no-repeat;
492 | }
493 | .expander.expanded {
494 |  background: url(../expander_open.png) 0 50% no-repeat;
495 |  padding-left: 12px;
496 |  margin-left: 0;
497 | }
498 | .expander.expanded:hover {
499 |  background: url(../expander_open_hover.png) 0 50% no-repeat;
500 | }
501 | 
502 | /* Section with count */
503 | h2 .trac-count, h3 .trac-count {
504 |  margin-left: .2em;
505 |  vertical-align: baseline;
506 |  color: #999;
507 |  font-size: 90%;
508 |  font-weight: normal;
509 | }
510 | 
511 | /* Page preferences form */
512 | #prefs {
513 |  background: #f7f7f0;
514 |  border: 1px outset #eee;
515 |  border-radius: 1em;
516 |  box-shadow: .2em .2em .7em 0 #777;
517 |  float: right;
518 |  font-size: 9px;
519 |  padding: .8em;
520 |  position: relative;
521 |  margin: 0 1em 1em;
522 | }
523 | #prefs input, #prefs select { font-size: 9px; vertical-align: middle }
524 | #prefs fieldset {
525 |  background: transparent;
526 |  border: none;
527 |  box-shadow: none;
528 |  margin: .5em;
529 |  padding: 0;
530 | }
531 | #prefs fieldset legend {
532 |  background: transparent;
533 |  color: #000;
534 |  font-size: 9px;
535 |  font-weight: normal;
536 |  margin: 0 0 0 -1.5em;
537 |  padding: 0;
538 | }
539 | #prefs .buttons { text-align: right }
540 | 
541 | /* Version information (browser, wiki, attachments) */
542 | #info {
543 |  margin: 1em 0 0 0;
544 |  background: #f7f7f0;
545 |  border: 1px solid #d7d7d7;
546 |  border-collapse: collapse;
547 |  border-spacing: 0;
548 |  clear: both;
549 |  width: 100%;
550 | }
551 | #info th, #info td { font-size: 85%; padding: 2px .5em; vertical-align: top }
552 | #info th { font-weight: bold; text-align: left }
553 | #info td.message { width: 100% }
554 | #info .message ul { padding: 0; margin: 0 2em }
555 | #info .message p { margin: 0; padding: 0 }
556 | a.trac-diff:after { content: "∆" }
557 | 
558 | /* Wiki */
559 | .wikipage { padding-left: 18px }
560 | .wikipage h1, .wikipage h2, .wikipage h3 { margin-left: -18px }
561 | .wikipage table h1, .wikipage table h2, .wikipage table h3 { margin-left: 0px }
562 | div.compact > p:first-child { margin-top: 0 }
563 | div.compact > p:last-child { margin-bottom: 0 }
564 | 
565 | /* Delete */
566 | #delete-confirm li { list-style-type: square; }
567 | 
568 | /* Styles related to RTL support */
569 | .rtl { direction: rtl; }
570 | .rtl div.wiki-toc { float: left; }
571 | .rtl .wiki-toc ul ul, .wiki-toc ol ol { padding-right: 1.2em }
572 | 
573 | a.missing:link, a.missing:visited, a.missing, span.missing,
574 | a.forbidden, span.forbidden { color: #998 }
575 | a.missing:hover { color: #000 }
576 | a.closed:link, a.closed:visited, span.closed { text-decoration: line-through }
577 | 
578 | /* User-selectable styles for blocks */
579 | .important {
580 |  background: #fcb;
581 |  border: 1px dotted #d00;
582 |  color: #500;
583 |  padding: 0 .5em 0 .5em;
584 |  margin: .5em;
585 | }
586 | 
587 | dl.wiki dt { font-weight: bold }
588 | dl.compact dt { float: left; padding-right: .5em }
589 | dl.compact dd { margin: 0; padding: 0 }
590 | 
591 | pre.wiki, pre.literal-block {
592 |  background: #f7f7f7;
593 |  border: 1px solid #d7d7d7;
594 |  box-shadow: 0 0 1em #eee;
595 |  border-radius: .3em;
596 |  margin: 1em 1.75em;
597 |  padding: .25em;
598 |  overflow: auto;
599 | }
600 | 
601 | div.wiki-code {
602 |  margin: 1em 1.75em;
603 | }
604 | 
605 | code, tt {
606 |  color: #600;
607 |  border: 1px solid #edc;
608 |  border-radius: .25em;
609 |  padding: 0 0.3em;
610 |  background: #fafafa;
611 | }
612 | 
613 | blockquote.citation {
614 |  margin: -0.6em 0 0 0;
615 |  border-style: solid;
616 |  border-width: 0 0 0 2px;
617 |  padding-left: .5em;
618 |  border-color: #b44;
619 | }
620 | .citation blockquote.citation { border-color: #4b4; }
621 | .citation .citation blockquote.citation { border-color: #44b; }
622 | .citation .citation .citation blockquote.citation { border-color: #c55; }
623 | 
624 | table.wiki {
625 |  border: 1px solid #ccc;
626 |  border-collapse: collapse;
627 |  border-spacing: 0;
628 |  box-shadow: 0 0 1em #eee; /* from pre.wiki */
629 | }
630 | table.wiki td { border: 1px solid #ccc;  padding: .1em .25em; }
631 | table.wiki th {
632 |  border: 1px solid #bbb;
633 |  padding: .1em .25em;
634 |  background-color: #f7f7f7;
635 | }
636 | table.wiki tbody tr.even { background-color: #fcfcfc }
637 | table.wiki tbody tr.odd { background-color: #f7f7f7 }
638 | 
639 | .wikitoolbar {
640 |  margin-top: 0.3em;
641 |  border: solid #d7d7d7;
642 |  border-width: 1px 1px 1px 0;
643 |  height: 18px;
644 |  width: 234px;
645 | }
646 | .wikitoolbar :link, .wikitoolbar :visited {
647 |  background: transparent url(../edit_toolbar.png) no-repeat;
648 |  border: 1px solid #fff;
649 |  border-left-color: #d7d7d7;
650 |  cursor: default;
651 |  display: block;
652 |  float: left;
653 |  width: 24px;
654 |  height: 16px;
655 | }
656 | .wikitoolbar :link:hover, .wikitoolbar :visited:hover {
657 |  background-color: transparent;
658 |  border: 1px solid #fb2;
659 | }
660 | .wikitoolbar a#em { background-position: 0 0 }
661 | .wikitoolbar a#strong { background-position: 0 -16px }
662 | .wikitoolbar a#heading { background-position: 0 -32px }
663 | .wikitoolbar a#link { background-position: 0 -48px }
664 | .wikitoolbar a#code { background-position: 0 -64px }
665 | .wikitoolbar a#hr { background-position: 0 -80px }
666 | .wikitoolbar a#np { background-position: 0 -96px }
667 | .wikitoolbar a#br { background-position: 0 -112px }
668 | .wikitoolbar a#img { background-position: 0 -128px }
669 | 
670 | /* Textarea resizer */
671 | div.trac-resizable { display: table; width: 100% }
672 | div.trac-resizable > div { display: table-cell }
673 | div.trac-resizable textarea { display: block; margin-bottom: 0 }
674 | div.trac-grip {
675 |  height: 5px;
676 |  overflow: hidden;
677 |  background: #eee url(../grip.png) no-repeat center 1px;
678 |  border: 1px solid #ddd;
679 |  border-top-width: 0;
680 |  cursor: s-resize;
681 | }
682 | 
683 | /* Styles for the list of attachments. */
684 | #attachments > div.attachments {
685 |  padding: 0 0 1em 1em;
686 | }
687 | #attachments dl.attachments { margin-left: 2em; padding: 0 }
688 | #attachments dt { display: list-item; list-style: square; }
689 | #attachments dd { font-style: italic; margin-left: 0; padding-left: 0; }
690 | #attachments p {
691 |  margin-left: 2em;
692 |  font-size: 90%;
693 |  color: #666;
694 | }
695 | #attachments > div.attachments > p {
696 |  float: right;
697 |  margin: .4em 0;
698 | }
699 | #attachments span.trac-author { font-style: italic; }
700 | 
701 | .attachment #preview { margin-top: 1em }
702 | 
703 | /* Styles for tabular listings such as those used for displaying directory
704 |    contents and report results. */
705 | table.listing {
706 |  clear: both;
707 |  border-bottom: 1px solid #d7d7d7;
708 |  border-collapse: collapse;
709 |  border-spacing: 0;
710 |  box-shadow: .2em .3em 1.5em #eee; /* from .trac-content */
711 |  margin-top: 1em;
712 |  width: 100%;
713 | }
714 | table.listing th { text-align: left; padding: 0 1em .1em 0; font-size: 12px }
715 | table.listing th.sel, table.listing td.sel { text-align: center; width: 1% }
716 | table.listing thead tr { background: #f7f7f0 }
717 | table.listing thead th {
718 |  border: 1px solid #d7d7d7;
719 |  border-bottom-color: #999;
720 |  font-size: 11px;
721 |  font-weight: bold;
722 |  padding: 2px .5em;
723 |  vertical-align: bottom;
724 |  white-space: nowrap;
725 | }
726 | table.listing thead th :link:hover, table.listing thead th :visited:hover {
727 |  background-color: transparent;
728 | }
729 | table.listing thead th a { border: none; padding-right: 12px }
730 | table.listing th.asc a, table.listing th.desc a {
731 |  font-weight: bold;
732 |  background-position: 100% 50%;
733 |  background-repeat: no-repeat;
734 | }
735 | table.listing th.asc a { background-image: url(../asc.png) }
736 | table.listing th.desc a { background-image: url(../desc.png) }
737 | table.listing tbody td, table.listing tbody th {
738 |  border: 1px dotted #ddd;
739 |  padding: .3em .5em;
740 |  vertical-align: top;
741 | }
742 | table.listing tbody td a:hover, table.listing tbody th a:hover {
743 |  background-color: transparent;
744 | }
745 | table.listing tbody tr { border-top: 1px solid #ddd }
746 | table.listing tbody tr.even { background-color: #fcfcfc }
747 | table.listing tbody tr.odd { background-color: #f7f7f7 }
748 | table.listing tbody tr:hover td { background: #eed !important }
749 | table.listing tbody tr.focus { background: #ddf !important }
750 | 
751 | table.listing pre { white-space: pre-wrap }
752 | 
753 | /* Styles for the page history table
754 |    (extends the styles for "table.listing") */
755 | #fieldhist td { padding: 0 .5em }
756 | #fieldhist td.date, #fieldhist td.diff, #fieldhist td.version,
757 | #fieldhist td.author {
758 |  white-space: nowrap;
759 | }
760 | #fieldhist td.version { text-align: center }
761 | #fieldhist td.comment { width: 100% }
762 | #fieldhist .inlinebuttons {
763 |  display: none;
764 |  float: right;
765 | }
766 | .uisymbols #fieldhist .inlinebuttons a { font-size: 85% }
767 | 
768 | /* Auto-completion interface */
769 | .suggestions { background: #fff; border: 1px solid #886; color: #222; }
770 | .suggestions ul {
771 |  font-family: sans-serif;
772 |  max-height: 20em;
773 |  min-height: 3em;
774 |  list-style: none;
775 |  margin: 0;
776 |  overflow: auto;
777 |  padding: 0;
778 |  width: 440px;
779 | }
780 | * html .suggestions ul { height: 10em; }
781 | .suggestions li { background: #fff; cursor: pointer; padding: 2px 5px }
782 | .suggestions li.selected { background: #b9b9b9 }
783 | 
784 | /* Styles for the error page */
785 | #content.error .message, div.system-message {
786 |  background: #fdc;
787 |  border: 2px solid #d00;
788 |  color: #500;
789 |  padding: .5em;
790 |  margin: 1em 0;
791 | }
792 | #content.error div.message pre, div.system-message pre {
793 |  margin-left: 1em;
794 |  overflow: hidden;
795 |  white-space: pre-wrap;
796 | }
797 | 
798 | div.system-message p { margin: 0 }
799 | div.system-message p.system-message-title { font-weight: bold; }
800 | 
801 | /* rst errors are less emphasized */
802 | span.system-message {
803 |  float: left;
804 |  background: #fdc;
805 |  padding: 0.2em;
806 |  margin: 1px;
807 |  border-radius: 0.25em;
808 | }
809 | 
810 | /* whole-page admonitions in theme.html */
811 | div.system-message {
812 |  border-radius: .5em;
813 |  /* taken from #prefs */
814 |  box-shadow: .2em .2em .7em 0 #777;
815 | }
816 | 
817 | #warning.system-message, .warning.system-message {
818 |  background: #ffb;
819 |  border: 1px solid #500;
820 | }
821 | #warning.system-message li { list-style-type: square; }
822 | 
823 | #notice.system-message, .notice.system-message {
824 |  background: #dfd;
825 |  border: 1px solid #500;
826 | }
827 | #notice.system-message li { list-style-type: square; }
828 | 
829 | div.system-message .trac-close-msg {
830 |  display: none; /* hidden when no Javascript available */
831 |  float: right;
832 |  font-size: 80%;
833 |  /* taken from .inlinebuttons */
834 |  border: 1px solid #ddd;
835 |  border-radius: 1em;
836 |  height: 1.6em;
837 |  padding: 0 .4em .1em;
838 |  box-shadow: none;
839 |  margin: 0 .1em .1em 0;
840 |  background: none;
841 |  color: #999;
842 |  /* taken from trac-delete */
843 |  color: #d31313;
844 |  /* override */
845 |  height: 1.4em;
846 | }
847 | div.system-message .trac-close-msg:hover {
848 |  /* taken from .inlinebuttons */
849 |  background: #f6f6f6;
850 |  color: #333;
851 |  text-shadow: .04em .04em #fcfcfc;
852 |  box-shadow: .1em .1em .6em 0 #999;
853 | }
854 | .uisymbols div.system-message .trac-close-msg > span {
855 |  display: none;
856 | }
857 | .uisymbols div.system-message .trac-close-msg:after {
858 |  content: "x"; /* or &ndash; "–"; */
859 | }
860 | 
861 | /* error.html page */
862 | #content.error form.newticket { display: inline; }
863 | #content.error form.newticket textarea { display: none; }
864 | 
865 | #content.error #traceback { margin-left: 1em; }
866 | #content.error #traceback :link, #content.error #traceback :visited {
867 |   border: none;
868 | }
869 | #content.error #tbtoggle { font-size: 80%; }
870 | #content.error #traceback div { margin-left: 1em; }
871 | #content.error #traceback h3 { font-size: 95%; margin: .5em 0 0; }
872 | #content.error #traceback :link var, #content.error #traceback :visited var {
873 |   font-family: monospace;
874 |   font-style: normal;
875 |   font-weight: bold;
876 | }
877 | #content.error #traceback span.file { color: #666; font-size: 85%; }
878 | #content.error #traceback ul { list-style: none; margin: .5em 0; padding: 0; }
879 | #content.error #traceback table.code td { white-space: pre; font-size: 90%; }
880 | #content.error #traceback table.code tr.current td { background: #e6e6e6; }
881 | #content.error #traceback table { margin: .5em 0 1em;  }
882 | #content.error #traceback th, #content.error #traceback td {
883 |   font-size: 85%; padding: 1px;
884 | }
885 | #content.error #traceback th var {
886 |   font-family: monospace;
887 |   font-style: normal;
888 | }
889 | #content.error #traceback td code { white-space: pre; }
890 | #content.error #traceback pre { font-size: 95%; }
891 | 
892 | #content .paging { margin: 0 0 2em; padding: .5em 0 0;
893 |   font-size: 85%; line-height: 2em; text-align: center;
894 | }
895 | #content .paging .current {
896 |   padding: .1em .3em;
897 |   border: 1px solid #333;
898 |   background: #999; color: #fff;
899 | }
900 | 
901 | #content .paging :link, #content .paging :visited {
902 |   padding: .1em .3em;
903 |   border: 1px solid #666;
904 |   background: transparent; color: #666;
905 | }
906 | #content .paging :link:hover, #content .paging :visited:hover {
907 |   background: #999; color: #fff;  border-color: #333;
908 | }
909 | #content .paging .previous a,
910 | #content .paging .next a {
911 |   font-size: 150%; font-weight: bold; border: none;
912 | }
913 | #content .paging .previous a:hover,
914 | #content .paging .next a:hover {
915 |   background: transparent; color: #666;
916 | }
917 | 
918 | #content h2 .numresults { color: #666; font-size: 90%; }
919 | 
920 | /* Styles for the About page */
921 | #content.about a.logo { border: none; float: right; margin-left: 2em; }
922 | #content.about a.logo img { display: block; }
923 | #content.about #python-logo img { width: 140px; height: 56px; }
924 | #content.about p.copyright { color: #999; font-size: 90%; }
925 | 
926 | /* Styles for environment info (error and about pages) */
927 | #environmentinfo h2 { margin-top: 2em; }
928 | #environmentinfo table { margin: 1em; width: auto; }
929 | #environmentinfo table th, #environmentinfo table td { border: 1px solid #ddd; font-size: 90%; }
930 | #environmentinfo table th { background: #f7f7f7; font-weight: bold; white-space: nowrap; }
931 | #environmentinfo table td.file { color: #666; }
932 | #environmentinfo table tr.disabled th,
933 | #environmentinfo table tr.disabled td { color: #999; }
934 | #environmentinfo #config th, #content.about #config td { padding: 3px; }
935 | #environmentinfo #config tr.modified { background: #ffd; }
936 | #environmentinfo #config tr.modified td.value { font-style: italic; }
937 | #environmentinfo #config td.doc { padding: 3px 1em; }
938 | 
939 | /* Styles for jquery-ui */
940 | .trac-placeholder { background: #eed }
941 | 
942 | /* Styles for search word highlighting */
943 | @media screen {
944 |  .searchword0 { background: #ff9 }
945 |  .searchword1 { background: #cfc }
946 |  .searchword2 { background: #cff }
947 |  .searchword3 { background: #ccf }
948 |  .searchword4 { background: #fcf }
949 | }
950 | 
951 | @media print {
952 |  #header, #altlinks, #footer, #help, #warning, #notice { display: none }
953 |  .nav, form, .buttons form, form .buttons, form .inlinebuttons,
954 |  .noprint, .trac-nav, .trac-topnav,
955 |  #attachments > div.attachments > p {
956 |   display: none;
957 |  }
958 |  form.printableform { display: block }
959 |  div.code pre { white-space: pre-wrap }
960 |  :link, :visited { border-bottom: none }
961 |  div.trac-content { box-shadow: none }
962 |  .foldable :link, .foldable :visited {
963 |   text-shadow: none;
964 |   box-shadow: none;
965 |  }
966 | }
967 | 


--------------------------------------------------------------------------------
/doc/SoulseekProtocol – Museek+_files/trac.js:
--------------------------------------------------------------------------------
  1 | (function($){
  2 | 
  3 |   if (typeof _ == 'undefined')
  4 |     babel.Translations.load({}).install();
  5 | 
  6 |   $.fn.addAnchor = function(title) {
  7 |     title = title || _("Link here");
  8 |     return this.filter("*[id]").each(function() {
  9 |       $("<a class='anchor'> \u00B6</a>").attr("href", "#" + this.id)
 10 |         .attr("title", title).appendTo(this);
 11 |     });
 12 |   };
 13 | 
 14 |   $.fn.checked = function(checked) {
 15 |     if (checked == undefined) { // getter
 16 |       if (!this.length) return false;
 17 |       return this.get(0).checked;
 18 |     } else { // setter
 19 |       return this.each(function() {
 20 |         this.checked = checked;
 21 |       });
 22 |     }
 23 |   };
 24 | 
 25 |   // Add a Select All checkbox to each thead in the table.
 26 |   $.fn.addSelectAllCheckboxes = function() {
 27 |     var $table = this;
 28 |     if ($("tr td.sel", $table).length > 0) {
 29 |       $("tr th.sel", $table).append(
 30 |         $('<input type="checkbox" name="toggle_group" />').attr({
 31 |           title: _("Toggle group")
 32 |         }).click(function() {
 33 |           $("tr td.sel input",
 34 |             $(this).closest("thead, tbody").next())
 35 |               .prop("checked", this.checked).change();
 36 |         })
 37 |       );
 38 |       $("tr td.sel", $table).click(function() {
 39 |         var $tbody = $(this).closest("tbody");
 40 |         var $checkboxes = $("tr td.sel input", $tbody);
 41 |         var num_selected = $checkboxes.filter(":checked").length;
 42 |         var none_selected = num_selected === 0;
 43 |         var all_selected = num_selected === $checkboxes.length;
 44 |         $("tr th.sel input", $tbody.prev())
 45 |           .prop({"checked": all_selected,
 46 |                  "indeterminate": !(none_selected || all_selected)});
 47 |       });
 48 |     }
 49 |   };
 50 | 
 51 |   // Conditionally disable the submit button. Returns a jQuery object.
 52 |   $.fn.disableSubmit = function(determinant) {
 53 |     determinant = $(determinant);
 54 |     var subject = $(this);
 55 |     var isDisabled;
 56 |     if (determinant.is("input:checkbox")) {
 57 |       isDisabled = function () {
 58 |           return determinant.filter(":checked").length === 0;
 59 |       }
 60 |     } else if (determinant.is("input:file")) {
 61 |       isDisabled = function () {
 62 |           return !determinant.val();
 63 |       }
 64 |     } else {
 65 |       return subject;
 66 |     }
 67 |     function toggleDisabled() {
 68 |       subject.prop("disabled", isDisabled);
 69 |       if (subject.prop("disabled")) {
 70 |         subject.attr("title", _("At least one item must be selected"))
 71 |       } else {
 72 |         subject.removeAttr("title");
 73 |       }
 74 |     }
 75 |     determinant.change(toggleDisabled);
 76 |     toggleDisabled();
 77 |     return subject;
 78 |   };
 79 | 
 80 |   $.fn.enable = function(enabled) {
 81 |     if (enabled == undefined) enabled = true;
 82 |     return this.each(function() {
 83 |       this.disabled = !enabled;
 84 |       var label = $(this).parents("label");
 85 |       if (!label.length && this.id) {
 86 |         label = $("label[for='" + this.id + "']");
 87 |       }
 88 |       if (!enabled) {
 89 |         label.addClass("disabled");
 90 |       } else {
 91 |         label.removeClass("disabled");
 92 |       }
 93 |     });
 94 |   };
 95 | 
 96 |   $.fn.getAbsolutePos = function() {
 97 |     return this.map(function() {
 98 |       var left = this.offsetLeft;
 99 |       var top = this.offsetTop;
100 |       var parent = this.offsetParent;
101 |       while (parent) {
102 |         left += parent.offsetLeft;
103 |         top += parent.offsetTop;
104 |         parent = parent.offsetParent;
105 |       }
106 |       return {left: left, top: top};
107 |     });
108 |   };
109 | 
110 |   $.fn.scrollToTop = function() {
111 |     return this.each(function() {
112 |       scrollTo(0, $(this).getAbsolutePos()[0].top);
113 |       return false;
114 |     });
115 |   };
116 | 
117 |   // Disable the form's submit action after the submit button is pressed by
118 |   // replacing it with a handler that cancels the action. The handler is
119 |   // removed when navigating away from the page so that the action will
120 |   // be enabled when using the back button to return to the page.
121 |   $.fn.disableOnSubmit = function() {
122 |     this.click(function() {
123 |       var form = $(this).closest("form");
124 |       if (form.hasClass("trac-submit-is-disabled")) {
125 |         form.bind("submit.prevent-submit", function() {
126 |           return false;
127 |         });
128 |         $(window).on("unload", function() {
129 |           form.unbind("submit.prevent-submit");
130 |         });
131 |       } else {
132 |         form.addClass("trac-submit-is-disabled");
133 |         $(window).on("unload", function() {
134 |           form.removeClass("trac-submit-is-disabled");
135 |         })
136 |       }
137 |     });
138 |   };
139 | 
140 |   $.loadStyleSheet = function(href, type) {
141 |     type = type || "text/css";
142 |     $(document).ready(function() {
143 |       var link;
144 |       $("link[rel=stylesheet]").each(function() {
145 |         if (this.getAttribute("href") === href) {
146 |           if (this.disabled)
147 |             this.disabled = false;
148 |           link = this;
149 |           return false;
150 |         }
151 |       });
152 |       if (link !== undefined)
153 |         return;
154 |       if (document.createStyleSheet) { // MSIE
155 |         document.createStyleSheet(href);
156 |       } else {
157 |         $("<link rel='stylesheet' type='" + type + "' href='" + href + "' />")
158 |           .appendTo("head");
159 |       }
160 |     });
161 |   };
162 | 
163 |   // {script.src: [listener1, listener2, ...]}
164 |   var readyListeners = {};
165 | 
166 |   $.documentReady = function(listener) {
167 |     var script = document.currentScript;
168 |     if (script === undefined) {
169 |       script = $("head script");
170 |       script = script[script.length - 1];
171 |     }
172 |     if (script) {
173 |       var href = script.getAttribute("src");
174 |       if (!(href in readyListeners))
175 |         readyListeners[href] = [];
176 |       var listeners = readyListeners[href];
177 |       listeners.push(listener);
178 |     }
179 |     $(document).ready(listener);
180 |   };
181 | 
182 |   $.loadScript = function(href, type, charset) {
183 |     var script;
184 |     $("head script").each(function() {
185 |       if (this.getAttribute("src") === href) {
186 |         script = this;
187 |         return false;
188 |       }
189 |     });
190 |     if (script !== undefined) {
191 |       // Call registered ready listeners
192 |       $.each(readyListeners[href] || [], function(idx, listener) {
193 |         listener.call(document, $);
194 |       });
195 |     } else {
196 |       // Don't use $("<script>").appendTo("head") to avoid adding
197 |       // "_=<timestamp>" parameter to url.
198 |       script = document.createElement("script");
199 |       script.src = href;
200 |       script.async = false;
201 |       script.type = type || "text/javascript";
202 |       script.charset = charset || "utf-8";
203 |       $("head")[0].appendChild(script);
204 |     }
205 |   };
206 | 
207 |   var warn_unsaved_changes;
208 | 
209 |   // Prompt a warning if leaving the page with unsaved changes
210 |   $.setWarningUnsavedChanges = function(enabled, message) {
211 |     if (enabled) {
212 |       if (!warn_unsaved_changes) {
213 |         $(window).bind("beforeunload", function() {
214 |           return warn_unsaved_changes;
215 |         });
216 |       }
217 |       warn_unsaved_changes = message || _("You have unsaved changes. Your " +
218 |         "changes will be lost if you leave this page before saving your " +
219 |         "changes.");
220 |     } else {
221 |       $(window).unbind("beforeunload");
222 |       warn_unsaved_changes = null;
223 |     }
224 |   };
225 | 
226 |   // Escape special HTML characters (&<>")
227 |   var quote = {"&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;"};
228 | 
229 |   $.htmlEscape = function(value) {
230 |     if (typeof value != "string")
231 |       return value;
232 |     return value.replace(/[&<>"]/g, function(c) { return quote[c]; });
233 |   };
234 | 
235 |   function format(str, args, escape) {
236 |     var kwargs = args[args.length - 1];
237 |     return str.replace(/\${?(\w+)}?/g, function(_, k) {
238 |       var result;
239 |       if (k.length == 1 && k >= '0' && k <= '9')
240 |         result = args[k - '0'];
241 |       else
242 |         result = kwargs[k];
243 |       return escape ? escape(result) : result;
244 |     });
245 |   }
246 | 
247 |   // Expand positional ($1 .. $9) and keyword ($name) arguments in a string.
248 |   // The htmlFormat() version HTML-escapes arguments prior to substitution.
249 |   $.format = function(str) {
250 |     return format(str, arguments);
251 |   };
252 | 
253 |   $.htmlFormat = function(str) {
254 |     return format(str, arguments, $.htmlEscape);
255 |   };
256 | 
257 |   $.template = $.format;    // For backward compatibility
258 | 
259 |   // Used for dynamically updating the height of a textarea
260 |   window.resizeTextArea = function (id, rows) {
261 |     var textarea = $("#" + id).get(0);
262 |     if (!textarea || textarea.rows == undefined) return;
263 |     $(textarea).height("");
264 |     textarea.rows = rows;
265 |   }
266 | 
267 | })(jQuery);
268 | 


--------------------------------------------------------------------------------
/doc/SoulseekProtocol – Museek+_files/trac_logo_mini.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/misterhat/livelook/630241218e6dbd6db19779bbf6e95c1ffe6a8b38/doc/SoulseekProtocol – Museek+_files/trac_logo_mini.png


--------------------------------------------------------------------------------
/doc/SoulseekProtocol – Museek+_files/wiki.css:
--------------------------------------------------------------------------------
  1 | @import url(code.css);
  2 | 
  3 | #info { margin: 0 0 1em 0 }
  4 | #wikipage { clear: both }
  5 | 
  6 | .wikipage h2 {
  7 |  border-bottom: 1px solid #ddd;
  8 |  box-shadow: .1em .4em .7em 0 #f2f2f2;
  9 |  padding: 0.2em .3em .1em;
 10 | }
 11 | @media print { .wikipage h2 { box-shadow: none } }
 12 | 
 13 | .wikipage h3 {
 14 |  border-bottom: 1px dashed #ddd;
 15 |  padding: 0.2em .3em .1em;
 16 | }
 17 | .wikipage .trac-content {
 18 |  margin-left: -18px;
 19 |  padding-left: 28px;
 20 | }
 21 | 
 22 | /* Styles for the path of hierarchical pages */
 23 | #pagepath {
 24 |  font-size: 10px; /* same as .nav ul in trac.css */
 25 |  float: left;
 26 |  padding: .4em 0;
 27 | }
 28 | #pagepath :link, #pagepath :visited { margin: 0 .2em }
 29 | #pagepath .first:link, #pagepath .first:visited { color: #998 }
 30 | #pagepath .sep { color: #666; padding: 0 .1em }
 31 | #pagepath .pathentry { float: left }
 32 | 
 33 | /* Styles for the page creation form */
 34 | .create #modifypage input { margin: 2px /* trac.css' input {} */ }
 35 | 
 36 | /* Styles for the page editing form */
 37 | .preview-right {
 38 |  float: right;
 39 |  width: 50%;
 40 |  display: block;
 41 |  margin: 0 0 0 1em;
 42 | }
 43 | .sidebyside > h2 { margin: .4em 0 }
 44 | .sidebyside #preview { margin: 0 }
 45 | .sidebyside #text { overflow: hidden }
 46 | 
 47 | #edit { margin-top: .5em }
 48 | #edit #rows {
 49 |  float: right;
 50 |  font-size: 80%;
 51 |  margin: .4em 0 0 0;
 52 | }
 53 | #edit #rows select { font-size: 90% }
 54 | #edit fieldset { margin-left: 1px; margin-right: 1px }
 55 | #edit #text {
 56 |  clear: both;
 57 |  min-height: 10em;
 58 |  resize: vertical;
 59 | }
 60 | #edit .wikitoolbar { float: left }
 61 | #edit div.trac-resizable { clear: both }
 62 | #edit + #info { margin-top: 1em }
 63 | #edit + #attachments { margin-top: 1.5em }
 64 | #delete, #rename, #save { margin-left: 3em }
 65 | #preview {
 66 |  background: #f8f8f8 url(../draft.png);
 67 |  margin: 1em 0 2em;
 68 |  overflow: auto;
 69 | }
 70 | 
 71 | /* Diff view */
 72 | #overview .multi { color: #999 }
 73 | #overview .ipnr { color: #999; font-size: 80% }
 74 | #overview .comment { padding: 1em 0 0 }
 75 | 
 76 | @media print {
 77 |  th.diff, td.diff { display: none }
 78 | }
 79 | 
 80 | /* Styles for the TracGuideToc wikimacro */
 81 | .wiki-toc {
 82 |  padding: .5em 1em;
 83 |  margin: 0 0 2em 1em;
 84 |  float: right;
 85 |  clear: right;
 86 |  border: 1px outset #ddc;
 87 |  background: #ffd;
 88 |  font-size: 85%;
 89 |  position: relative;
 90 | }
 91 | .wiki-toc h4 { font-size: 12px; margin: 0 }
 92 | .wiki-toc ul, .wiki-toc ol { list-style: none; padding: 0; margin: 0 }
 93 | .wiki-toc ul ul, .wiki-toc ol ol { padding-left: 1.2em }
 94 | .wiki-toc li { margin: 0; padding: 0 }
 95 | .wiki-toc .active { background: #ff9; position: relative; }
 96 | .wiki-toc-un ul, .wiki-toc-un ol { list-style: none; }
 97 | 
 98 | div.trac-modifiedby {
 99 |  margin: .3em .5em;
100 |  *width: 100%; /* Workaround horizontal scrollbar on IE7 */
101 |  color: #888;
102 |  font-size: 80%;
103 |  font-style: italic;
104 |  text-align: right;
105 |  float: right;
106 | }
107 | div.trac-modifiedby :link, div.trac-modifiedby :visited { color: inherit }
108 | div.trac-modifiedby span.trac-print { display: none; }
109 | @media print {
110 |  div.trac-modifiedby span { display: none; }
111 |  div.trac-modifiedby span.trac-print { display: block; }
112 | }
113 | 
114 | /* TracIni default value */
115 | div.tracini td.default { font-size: 90% }
116 | div.tracini td.nodefault {
117 |  color: #777;
118 |  font-size: 85%;
119 |  font-style: italic;
120 |  white-space: nowrap;
121 | }
122 | div.tracini td > p:first-child { margin-top: 0 }
123 | div.tracini td > p:last-child { margin-bottom: 0 }
124 | 


--------------------------------------------------------------------------------
/index.js:
--------------------------------------------------------------------------------
  1 | const Client = require('./lib/client');
  2 | const DistribPeer = require('./lib/distrib-peer');
  3 | const EventEmitter = require('events').EventEmitter;
  4 | const Peer = require('./lib/peer');
  5 | const PeerServer = require('./lib/peer-server');
  6 | const ThrottleGroup = require('stream-throttle').ThrottleGroup;
  7 | const buildList = require('./lib/build-list');
  8 | const chokidar = require('chokidar');
  9 | const makeToken = require('./lib/make-token');
 10 | const path = require('path');
 11 | const pkg = require('./package');
 12 | const searchShareList = require('./lib/search-share-list');
 13 | const stream = require('stream');
 14 | const uploadSpeed = require('./lib/upload-speed');
 15 | 
 16 | class LiveLook extends EventEmitter {
 17 |     constructor(args) {
 18 |         super();
 19 | 
 20 |         this.username = args.username;
 21 |         this.password = args.password;
 22 |         this.server = args.server || 'server.slsknet.org';
 23 |         this.port = args.port || 2242;
 24 |         this.waitPort = args.waitPort || 2234;
 25 |         this.sharedFolder = args.sharedFolder;
 26 |         this.downloadFolder = args.downloadFolder;
 27 |         this.description = args.description || pkg.homepage;
 28 |         this.autojoin = args.autojoin || [];
 29 |         this.maxPeers = args.maxPeers || 100;
 30 |         this.uploadSlots = args.uploadSlots || 2;
 31 |         this.downloadSlots = args.downloadSlots || 2;
 32 |         this.uploadThrottle = args.uploadThrottle || 56 * 1024;
 33 |         this.downloadThrottle = args.downloadThrottle || 56 * 1024;
 34 | 
 35 |         if (!Array.isArray(this.autojoin)) {
 36 |             this.autojoin = [ this.autojoin ];
 37 |         }
 38 | 
 39 |         // our online status (1 away, 2 online)
 40 |         this.status = 2;
 41 | 
 42 |         // the share list
 43 |         // { dir: [ { file, size, ... } ]
 44 |         this.shareList = {};
 45 | 
 46 |         // these are only P type peers, not F or D
 47 |         // { ip: { Peer } }
 48 |         this.peers = {};
 49 | 
 50 |         // when we send off a connect to peer request to the server, we send
 51 |         // the type (P, F, D) and a token. the peer will send us back the token
 52 |         // but not the type, so keep track of those.
 53 |         // { connectToken: cType }
 54 |         this.pendingPeers = {};
 55 | 
 56 |         // our parent D peer
 57 |         this.parentPeer = null;
 58 | 
 59 |         // peers that could be our parent. sent from netinfo after we say we're
 60 |         // orphaned
 61 |         this.potentialParents = [];
 62 | 
 63 |         // child peers to send search results to from our parent peer
 64 |         this.childPeers = {};
 65 | 
 66 |         // how far we are down the family tree (how many parents our parent has)
 67 |         this.branchLevel = 0;
 68 | 
 69 |         // who our parent is
 70 |         this.branchRoot = '';
 71 | 
 72 |         // how many children we should accept at max. i'm hardcoding 10 for now
 73 |         // but it should be a ratio packet they send divided by our speed. TODO.
 74 |         this.maxChildren = 10;
 75 | 
 76 |         // { username: { ip, port } }
 77 |         this.peerAddresses = {};
 78 | 
 79 |         // our *active* transfers
 80 |         // { token: { file: { file, size, ... }, dir: String, peer: Peer } }
 81 |         this.uploads = {};
 82 |         this.downloads = {};
 83 | 
 84 |         // pending transfers
 85 |         // [ ]
 86 |         this.uploadQueue = [];
 87 |         this.downloadQueue = [];
 88 | 
 89 |         // not exactly a queue - these are files we requested and others have
 90 |         // queued
 91 |         // { file: { file, size, ... } }
 92 |         this.toDownload = {};
 93 | 
 94 |         // which rooms we're in
 95 |         // { room: [ { users }, ... ] }
 96 |         this.rooms = {};
 97 | 
 98 |         // ticker messages! these usually spam on the top of the chatroom you're
 99 |         // in. an alternate implementation could use them as status messages
100 |         // { room: { username: tickerMessage } }
101 |         this.tickers = {};
102 | 
103 |         // cache gzipped search results (?) and our shares
104 |         this.cache = {};
105 | 
106 |         // TODO add ability to change the rate later
107 |         this.uploadThrottler = new ThrottleGroup({ rate: this.uploadThrottle });
108 |         this.downloadThrottler = new ThrottleGroup({
109 |             rate: this.downloadThrottle
110 |         });
111 | 
112 |         // the connection to soulseek's server
113 |         this.client = new Client({ ip: this.server, port: this.port });
114 |         this.client.attachHandlers(this);
115 | 
116 |         // our server to accept peer connections
117 |         this.peerServer = new PeerServer({
118 |             port: this.waitPort,
119 |             maxPeers: this.maxPeers
120 |         }, this);
121 | 
122 |         this.peerServer.on('error', err => this.emit('error', err));
123 |         this.peerServer.on('waitPort', waitPort => this.setWaitPort(waitPort));
124 | 
125 |         // are we sucessfully logged in?
126 |         this.loggedIn = false;
127 | 
128 |         // the last time we searched (i don't want to accidentally send too
129 |         // many)
130 |         this.lastSearch = -1;
131 | 
132 |         // the time we sent a successful search
133 |         this.lastSelfSearch = -1;
134 | 
135 |         // the last time we broadcasted a search to our children
136 |         this.lastBroadcastSearch = -1;
137 |     }
138 | 
139 |     // populate our share list and connect to the soulseek server
140 |     init(done) {
141 |         done = done || (() => {});
142 | 
143 |         // TODO reverse these i think
144 |         this.refreshShareList(err => {
145 |             if (err) {
146 |                 return done(err);
147 |             }
148 | 
149 |             this.client.init(done);
150 |         });
151 |     }
152 | 
153 |     // initialize our sharelist (object defining directories and files to share)
154 |     // can be called before we log in or any time after to refresh
155 |     refreshShareList(done) {
156 |         done = done || (() => {});
157 | 
158 |         buildList.shares(this.sharedFolder, (err, shareList) => {
159 |             if (err) {
160 |                 this.emit('error', err);
161 |                 return done(err);
162 |             }
163 | 
164 |             this.shareList = shareList;
165 |             this.refreshShareCount();
166 | 
167 |             if (this.shareWatcher) {
168 |                 return done(null, this.shareList);
169 |             }
170 | 
171 |             this.shareWatcher = chokidar.watch(this.sharedFolder, {
172 |                 // without this, i was getting 'add' fires before it could
173 |                 // read metadata.
174 |                 awaitWriteFinish: {
175 |                     stabilityThreshold: 1000
176 |                 },
177 |                 cwd: this.sharedFolder + '/../',
178 |                 ignoreInitial: true
179 |             });
180 | 
181 |             this.shareWatcher.on('add', file => {
182 |                 let dir = path.dirname(file);
183 |                 let ext = path.extname(file).slice(1);
184 | 
185 |                 // we could listen for addDir, but it fires a new request
186 |                 // for each subdirectory and there might not be any files
187 |                 // there. our structure requires the full directory path as
188 |                 // the key.
189 |                 if (!this.shareList.hasOwnProperty(dir)) {
190 |                     this.shareList[dir] = [];
191 |                 }
192 | 
193 |                 // TODO maybe a setTimeout here for good measure
194 |                 buildList.metaData(file, (err, metadata) => {
195 |                     if (err) {
196 |                         return this.emit('error', err);
197 |                     }
198 | 
199 |                     metadata.file = path.basename(file);
200 |                     metadata.extension = ext;
201 |                     this.shareList[dir].push(metadata);
202 |                     this.refreshShareCount();
203 |                 });
204 |             });
205 | 
206 |             this.shareWatcher.on('unlinkDir', dir => {
207 |                 if (this.shareList.hasOwnProperty(dir)) {
208 |                     delete this.shareList[dir];
209 |                     this.refreshShareCount();
210 |                 }
211 |             });
212 | 
213 |             this.shareWatcher.on('unlink', file => {
214 |                 let dir = path.dirname(file);
215 | 
216 |                 if (!this.shareList.hasOwnProperty(dir)) {
217 |                     return;
218 |                 }
219 | 
220 |                 for (let i = 0; i < this.shareList[dir].length; i += 1) {
221 |                     let cFile = this.shareList[dir][i];
222 | 
223 |                     if (cFile.file === file) {
224 |                         this.shareList[dir].splice(i, 1);
225 |                         this.refreshShareCount();
226 |                         return;
227 |                     }
228 |                 }
229 |             });
230 | 
231 |             this.shareWatcher.on('change', file => {
232 |                 let dir = path.dirname(file);
233 | 
234 |                 if (!this.shareList.hasOwnProperty(dir)) {
235 |                     return;
236 |                 }
237 | 
238 |                 for (let i = 0; i < this.shareList[dir].length; i += 1) {
239 |                     let cFile = this.shareList[dir][i];
240 | 
241 |                     if (cFile.file === file) {
242 |                         buildList.metaData(file, (err, metadata) => {
243 |                             if (err) {
244 |                                 return this.emit('error', err);
245 |                             }
246 | 
247 |                             metadata.file = path.basename(file);
248 |                             metadata.extension = ext;
249 |                             this.shareList[dir][i] = metadata;
250 |                             this.refreshShareCount();
251 |                         });
252 | 
253 |                         return;
254 |                     }
255 |                 }
256 |             });
257 | 
258 |             return done(null, shareList);
259 |         });
260 |     }
261 | 
262 |     // login (or connect first) to the soulseek server and send our initializing
263 |     // packets (upload speed, share count, joined rooms, etc.)
264 |     login(done) {
265 |         if (!this.client.connected) {
266 |             this.init((err) => {
267 |                 this.login(done);
268 |             });
269 | 
270 |             return;
271 |         }
272 | 
273 |         this.client.once('login', res => {
274 |             this.loggedIn = res.success;
275 | 
276 |             if (!this.loggedIn) {
277 |                 return done(null, res);
278 |             }
279 | 
280 |             this.refreshShareCount();
281 |             this.refreshUploadSpeed();
282 |             this.autojoin.forEach(room => this.joinRoom(room));
283 | 
284 |             if (this.peerServer.connected) {
285 |                 return done(null, res);
286 |             }
287 | 
288 |             this.peerServer.init(err => {
289 |                 if (err) {
290 |                     this.emit('error', err);
291 |                     return done(err);
292 |                 }
293 | 
294 |                 done(null, res);
295 |             });
296 | 
297 |             setTimeout(() => {
298 |                 this.refreshParentInfo();
299 |                 this.connectToNextParent();
300 |             }, 1000);
301 |         });
302 | 
303 |         this.client.send('login', this.username, this.password);
304 |     }
305 | 
306 |     // this is the port our peer server listens on
307 |     setWaitPort(port) {
308 |         if (port) {
309 |             this.waitPort = port;
310 |         }
311 | 
312 |         this.client.send('setWaitPort', this.waitPort);
313 |     }
314 | 
315 |     sayChatroom(room, message) {
316 |         this.client.send('sayChatroom', room, message);
317 |     }
318 | 
319 |     leaveChatroom(room) {
320 |         this.client.send('leaveChatroom', room);
321 |     }
322 | 
323 |     joinRoom(room) {
324 |         this.client.send('joinRoom', room);
325 |     }
326 | 
327 |     messageUser(username, message) {
328 |         this.client.send('messageUser', username, message);
329 |     }
330 | 
331 |     // accepts 2 for online, 1 for away, or the corresponding strings
332 |     setStatus(status) {
333 |         if (status) {
334 |             if (!isNaN(+status)) {
335 |                 this.status = status;
336 |             } else {
337 |                 this.status = status === 'online' ? 2 : 1;
338 |             }
339 |         }
340 | 
341 |         this.client.send('setStatus', this.status);
342 |     }
343 | 
344 |     // count the amount of files we're sharing and send them to the server
345 |     refreshShareCount() {
346 |         if (!this.loggedIn) {
347 |             return;
348 |         }
349 | 
350 |         let dirs = Object.keys(this.shareList).length;
351 |         let files = 0;
352 | 
353 |         for (let dir of Object.keys(this.shareList)) {
354 |             files += this.shareList[dir].length;
355 |         }
356 | 
357 |         this.client.send('sharedFoldersFiles', dirs, files);
358 |     }
359 | 
360 |     // fetch the upload speed from speedtest.net's api
361 |     refreshUploadSpeed(done) {
362 |         done = done || (() => {});
363 | 
364 |         uploadSpeed((err, speed) => {
365 |             if (err) {
366 |                 this.emit('error', err);
367 |                 return done(err);
368 |             }
369 | 
370 |             this.uploadSpeed = speed;
371 |             this.client.send('sendUploadSpeed', this.uploadSpeed);
372 |             done(null, speed);
373 |         });
374 |     }
375 | 
376 |     // fetch one of our shared files (usually to send to another user)
377 |     getSharedFile(filePath) {
378 |         let file = filePath.replace(/\\/g, '/');
379 |         let dir = path.dirname(file);
380 |         let basename = path.basename(file);
381 | 
382 |         let mappedDir = this.shareList[dir];
383 |         mappedDir = mappedDir ? mappedDir.map(file => file.file) : [];
384 |         let filePos = mappedDir.indexOf(basename);
385 | 
386 |         if (filePos === -1) {
387 |             return null;
388 |         }
389 | 
390 |         return this.shareList[dir][filePos];
391 |     }
392 | 
393 |     // check if the transfer is already in progress
394 |     isTransferring(transfer, isUpload) {
395 |         let transfers = isUpload ? this.uploads : this.downloads;
396 | 
397 |         for (let token of Object.keys(transfers)) {
398 |             let c = transfers[token];
399 |             let isSending = c.peer.ip === transfer.peer.ip &&
400 |                 c.file.file === transfer.file.file && c.dir === transfer.dir;
401 | 
402 |             if (isSending) {
403 |                 return true;
404 |             }
405 |         }
406 | 
407 |         return false;
408 |     }
409 | 
410 |     // get the position of an upload for a peer
411 |     getUploadQueuePos(upload) {
412 |         for (let i = 0; i < this.uploadQueue.length; i += 1) {
413 |             let toUpload = this.uploadQueue[i];
414 |             let isQueued = toUpload.peer.ip === upload.peer.ip &&
415 |                 toUpload.file.file === upload.file.file &&
416 |                 toUpload.dir === upload.dir;
417 | 
418 |             if (isQueued) {
419 |                 return i;
420 |             }
421 |         }
422 | 
423 |         return -1;
424 |     }
425 | 
426 |     // get the ip and address of a user from their username
427 |     getPeerAddress(username, done) {
428 |         if (this.peerAddresses[username]) {
429 |             return done(null, this.peerAddresses[username]);
430 |         }
431 | 
432 |         this.client.send('getPeerAddress', username);
433 | 
434 |         let onAddress;
435 | 
436 |         let addressTimeout = setTimeout(() => {
437 |             this.removeListener('getPeerAddress', onAddress);
438 |             done(new Error(`timed out fetching ${username} address`));
439 |         }, 5000);
440 | 
441 |         onAddress = res => {
442 |             if (res.username === username) {
443 |                 clearTimeout(addressTimeout);
444 |                 this.removeListener('getPeerAddress', onAddress);
445 | 
446 |                 if (res.ip === '0.0.0.0' && res.port === 0) {
447 |                     done(new Error(`${username} is offline.`));
448 |                 } else {
449 |                     done(null, res);
450 |                 }
451 |             }
452 |         };
453 | 
454 |         this.on('getPeerAddress', onAddress);
455 |     }
456 | 
457 |     // connect to a peer from an IP address and port (and token if available)
458 |     connectToPeerAddress(address, cType, done) {
459 |         if (!done) {
460 |             done = cType;
461 |             cType = 'P';
462 |         }
463 | 
464 |         let finished = false;
465 | 
466 |         let connectTimeout = setTimeout(() => {
467 |             done(new Error('timed out connecting to address directly:' +
468 |                 `${address.ip}:${address.port}`));
469 |         }, 5000);
470 | 
471 |         // try to connect to them directly...
472 |         let peer;
473 |         if (cType === 'P') {
474 |             peer = new Peer(address);
475 |         } else if (cType === 'D') {
476 |             peer = new DistribPeer(address);
477 |         }
478 | 
479 |         peer.token = makeToken();
480 | 
481 |         peer.once('error', err => {
482 |             if (!finished) {
483 |                 clearTimeout(connectTimeout);
484 |                 finished = true;
485 |                 done(err);
486 |             }
487 |         });
488 | 
489 |         peer.attachHandlers(this);
490 |         peer.init(() => {
491 |             if (!finished) {
492 |                 clearTimeout(connectTimeout);
493 |                 finished = true;
494 |                 //peer.pierceFirewall();
495 |                 peer.send('peerInit', this.username, cType, peer.token);
496 |                 done(null, peer);
497 |             }
498 |         });
499 |     }
500 | 
501 |     // try to establish a connection to a peer with soulseek's server as an
502 |     // intermediate. this is usually done after we try to directly connect
503 |     // to them. don't use this directly
504 |     connectToPeerUsername(username, cType, done) {
505 |         if (!done) {
506 |             done = type;
507 |             cType = 'P';
508 |         }
509 | 
510 |         // all the closures here need access to these to remove them when
511 |         // completed
512 |         let onCantConnect, onPeerConnect;
513 | 
514 |         let token = makeToken();
515 |         this.pendingPeers[token] = cType;
516 | 
517 |         let peerTimeout = setTimeout(() => {
518 |             this.removeListener('cantConnectToPeer', onCantConnect);
519 |             this.removeListener('peerConnect', onPeerConnect);
520 |             done(new Error('peer took longer than 5 seconds to connect to us'));
521 |         }, 5000);
522 | 
523 |         // server let us know the peer couldn't connect to us
524 |         onCantConnect = res => {
525 |             if (res.token === token) {
526 |                 clearTimeout(peerTimeout);
527 |                 this.removeListener('cantConnectToPeer', onCantConnect);
528 |                 this.removeListener('peerConnect', onPeerConnect);
529 |                 done(new Error(`peer ${username} can't connect to us at all`));
530 |             }
531 |         };
532 | 
533 |         // we connected to a peer, but it may not have been the one we fired off
534 |         // here
535 |         onPeerConnect = peer => {
536 |             if (peer.token === token) {
537 |                 clearTimeout(peerTimeout);
538 |                 this.removeListener('cantConnectToPeer', onCantConnect);
539 |                 this.removeListener('peerConnect', onPeerConnect);
540 |                 done(null, peer);
541 |             }
542 |         };
543 | 
544 |         this.on('cantConnectToPeer', onCantConnect);
545 |         this.on('peerConnect', onPeerConnect);
546 |         this.client.send('connectToPeer', token, username, cType);
547 |     }
548 | 
549 |     // get a Peer instance from a username string by any mean's necessary!
550 |     getPeerByUsername(username, cType, done) {
551 |         if (!done) {
552 |             done = cType;
553 |             cType = 'P';
554 |         }
555 | 
556 |         // first check our already-connected peers
557 |         if (cType === 'P') {
558 |             for (let ip of Object.keys(this.peers)) {
559 |                 let peer = this.peers[ip];
560 | 
561 |                 if (peer.username === username) {
562 |                     return done(null, peer);
563 |                 }
564 |             }
565 |         }
566 | 
567 |         this.getPeerAddress(username, (err, address) => {
568 |             if (err) {
569 |                 return done(err);
570 |             }
571 | 
572 |             this.connectToPeerAddress(address, cType, (err, peer) => {
573 |                 if (err) {
574 |                     // TODO maybe send 1001 here?
575 |                     this.connectToPeerUsername(username, cType, done);
576 |                     return;
577 |                 }
578 | 
579 |                 done(null, peer);
580 |             });
581 |         });
582 |     }
583 | 
584 |     // see which files a user is sharing
585 |     // TODO cache this!!
586 |     getShareFileList(username, done) {
587 |         this.getPeerByUsername(username, (err, peer) => {
588 |             let onShareList;
589 | 
590 |             if (err) {
591 |                 return done(err);
592 |             }
593 | 
594 |             let shareListTimeout = setTimeout(() => {
595 |                 this.removeListener('sharedFileList', onShareList);
596 |                 done(new Error('timed out getting share file list for ' +
597 |                     username));
598 |             }, 15000); // this is a pretty generous time
599 | 
600 |             onShareList = res => {
601 |                 if (res.peer.username === username) {
602 |                     clearTimeout(shareListTimeout);
603 |                     this.removeListener('sharedFileList', onShareList);
604 |                     done(null, res.shareList);
605 |                 }
606 |             };
607 | 
608 |             this.on('sharedFileList', onShareList);
609 |             peer.send('getShareFileList');
610 |         });
611 |     }
612 | 
613 |     // search a specific user's shares
614 |     searchUserShares(username, query, done) {
615 |         this.getPeerByUsername(username, (err, peer) => {
616 |             let onSearchResult;
617 | 
618 |             if (err) {
619 |                 return done(err);
620 |             }
621 | 
622 |             let token = makeToken();
623 | 
624 |             let searchTimeout = setTimeout(() => {
625 |                 this.removeListener('fileSearchResult', onSearchResult);
626 |                 done(new Error('timed out searching share file list for ' +
627 |                     username));
628 |             }, 15000);
629 | 
630 |             onSearchResult = res => {
631 |                 // it's unlikely but we could've generated the same token
632 |                 // twice
633 |                 if (res.peer.username === username && res.token === token) {
634 |                     clearTimeout(searchTimeout);
635 |                     this.removeListener('fileSearchResult', onSearchResult);
636 |                     done(null, res);
637 |                 }
638 |             };
639 | 
640 |             this.on('fileSearchResult', onSearchResult);
641 |             peer.send('fileSearchRequest', token, query);
642 |         });
643 |     }
644 | 
645 |     getUserInfo(username, done) {
646 |         this.getPeerByUsername(username, (err, peer) => {
647 |             let onInfoReply;
648 | 
649 |             if (err) {
650 |                 return done(err);
651 |             }
652 | 
653 |             let infoTimeout = setTimeout(() => {
654 |                 this.removeListener('fileSearchResult', onSearchResult);
655 |                 done(new Error('timed out fetchung user info for ' + username));
656 |             }, 5000);
657 | 
658 |             onInfoReply = res => {
659 |                 if (res.peer.username === username) {
660 |                     clearTimeout(infoTimeout);
661 |                     this.removeListener('userInfoReply', onInfoReply);
662 |                     done(null, res);
663 |                 }
664 |             };
665 | 
666 |             this.on('userInfoReply', onInfoReply);
667 |             peer.send('userInfoRequest');
668 |         });
669 |     }
670 | 
671 |     // request the contents of a specific directory of a peer
672 |     getFolderContents(username, dir, done) {
673 |         dir = dir.replace(/\//g, '\\');
674 | 
675 |         this.getPeerByUsername(username, (err, peer) => {
676 |             let onFolderResponse;
677 | 
678 |             if (err) {
679 |                 return done(err);
680 |             }
681 | 
682 |             let folderTimeout = setTimeout(() => {
683 |                 this.removeListener('folderContentsResponse', onFolderResponse);
684 |                 done(new Error('timed out getting folder response for ' +
685 |                     username));
686 |             }, 5000);
687 | 
688 |             onFolderResponse = res => {
689 |                 let resDir = Object.keys(res.requests)[0];
690 | 
691 |                 if (res.peer.username === username && resDir === dir) {
692 |                     clearTimeout(folderTimeout);
693 |                     this.removeListener('folderContentsResponse',
694 |                         onFolderResponse);
695 |                     done(null, res.requests[resDir]);
696 |                 }
697 |             };
698 | 
699 |             this.on('folderContentsResponse', onFolderResponse);
700 |             peer.send('folderContentsRequest', dir);
701 |         });
702 |     }
703 | 
704 |     // download a file from a user. the file should be the full path
705 |     downloadFile(username, file, fileStart = 0) {
706 |         let downloadStream = new stream.PassThrough();
707 | 
708 |         this.getPeerByUsername(username, (err, peer) => {
709 |             if (err) {
710 |                 return downloadStream.emit('error', err);
711 |             }
712 | 
713 |             let token = makeToken();
714 | 
715 |             let download = {
716 |                 file: path.basename(file),
717 |                 dir: path.dirname(file),
718 |                 fileStart,
719 |                 peer
720 |             };
721 | 
722 |             // TODO check download sslots
723 |             this.downloads[token] = download;
724 | 
725 |             let onQueue = res => {
726 |                 if (res.token === token) {
727 |                     this.removeListener('queueDownload', onQueue);
728 |                     downloadStream.emit('queue');
729 |                 }
730 |             };
731 | 
732 |             let onStart = res => {
733 |                 if (!(res.download.file === download.file &&
734 |                     res.download.dir === download.dir)) {
735 |                     return;
736 |                 }
737 | 
738 |                 this.removeListener('startDownload', onStart);
739 |                 this.removeListener('queueDownload', onQueue);
740 | 
741 |                 // this could be the same token we generated, or a new one if
742 |                 // they queued us and generated a new transfer request
743 |                 let downloadToken = res.token;
744 | 
745 |                 let onData = res => {
746 |                     if (res.token === downloadToken) {
747 |                         downloadStream.write(res.data);
748 |                     }
749 |                 };
750 | 
751 |                 let onEnd = res => {
752 |                     if (res.token === downloadToken) {
753 |                         this.removeListener('endDownload', onEnd);
754 |                         this.removeListener('fileData', onData);
755 |                         downloadStream.end();
756 |                     }
757 |                 };
758 | 
759 |                 this.on('fileData', onData);
760 |                 this.on('endDownload', onEnd);
761 |             };
762 | 
763 |             this.on('startDownload', onStart);
764 |             file = file.replace(/\//g, '\\');
765 |             peer.send('transferRequest', 0, token, file);
766 |         });
767 | 
768 |         return downloadStream;
769 |     }
770 | 
771 |     // search other peers for files
772 |     searchFiles(query, args = {}, done) {
773 |         if (typeof args === 'function') {
774 |             done = args;
775 |             args = {};
776 |         }
777 | 
778 |         if (!done) {
779 |             done = () => {};
780 |         }
781 | 
782 |         args.timeout = args.timeout || 5000;
783 |         args.max = args.max || 500;
784 | 
785 |         let searchSpew = new stream.PassThrough({ objectMode: true });
786 | 
787 |         if ((Date.now() - this.lastSearched) < 1000) {
788 |             let err = new Error('last search was <1s ago!');
789 |             process.nextTick(() => searchSpew.emit('error', err));
790 |             done(err);
791 |             return searchSpew;
792 |         }
793 | 
794 |         this.lastSearch = Date.now();
795 | 
796 |         let token = makeToken();
797 | 
798 |         let onResult;
799 |         let results = [];
800 | 
801 |         let searchTimeout = setTimeout(() => {
802 |             this.removeListener('fileSearchResult', onResult);
803 |             searchSpew.end();
804 |             done(null, results);
805 |         }, args.timeout);
806 | 
807 |         onResult = res => {
808 |             if (res.token === token) {
809 |                 for (let file of res.fileList) {
810 |                     if (results.length >= args.max) {
811 |                         clearTimeout(searchTimeout);
812 |                         this.removeListener('fileSearchResult', onResult);
813 |                         searchSpew.end();
814 |                         done(null, results);
815 |                         return;
816 |                     }
817 | 
818 |                     let result = {
819 |                         username: res.username,
820 |                         file: file.file,
821 |                         size: file.size,
822 |                         bitrate: file.bitrate,
823 |                         vbr: file.vbr,
824 |                         duration: file.duration,
825 |                         slotsFree: res.slotsFree,
826 |                         speed: res.speed,
827 |                         queueSize: res.queueSize
828 |                     };
829 | 
830 |                     results.push(result);
831 |                     searchSpew.write(result);
832 |                 }
833 |             }
834 |         };
835 | 
836 |         this.on('fileSearchResult', onResult);
837 |         this.client.send('fileSearch', token, query);
838 | 
839 |         return searchSpew;
840 |     }
841 | 
842 |     // respond to direct or distributed file search requests
843 |     respondToPeerSearch(username, token, query, something) {
844 |         if ((Date.now() - this.lastBroadcastSearch) > 5000) {
845 |             this.sendToChildren('search', {
846 |                 username, token, query, something
847 |             });
848 |             this.lastBroadcastSearch = Date.now();
849 |         }
850 | 
851 |         if (username !== 'fourfish') {
852 |             if ((Date.now() - this.lastSelfSearch) < 10000) {
853 |                 //console.log('too frequent searching bro');
854 |                 return;
855 |             }
856 |         }
857 | 
858 |         let files = searchShareList.search(this.shareList, query);
859 | 
860 |         if (files.length) {
861 |             console.log('found', files.length, ' for ', query);
862 | 
863 |             this.getPeerByUsername(username, (err, peer) => {
864 |                 if (err) {
865 |                     return this.emit('error', err);
866 |                 }
867 | 
868 |                 this.lastSelfSearch = Date.now();
869 | 
870 |                 peer.send('fileSearchResult', {
871 |                     username: this.username,
872 |                     token,
873 |                     fileList: files,
874 |                     slotsFree: !Object.keys(this.uploads).length,
875 |                     speed: this.uploadSpeed,
876 |                     queueSize: 0 // TODO put our real queue size here
877 |                 });
878 |             });
879 |         }
880 |     }
881 | 
882 |     // tell the server about our parent and child information
883 |     refreshParentInfo() {
884 |         this.client.send('haveNoParent', !this.parentPeer);
885 |         this.client.send('parentIp', this.parentPeer ? this.parentPeer.ip : '');
886 |         this.client.send('branchLevel', this.branchLevel);
887 |         this.client.send('branchRoot', this.branchRoot);
888 |         this.client.send('childDepth', Object.keys(this.childPeers).length);
889 |         let atCapacity = Object.keys(this.childPeers).length;
890 |         atCapacity = atCapacity >= this.maxChildren;
891 |         this.client.send('acceptChildren', (this.parentPeer && !atCapacity));
892 |         this.sendToChildren('branchLevel', this.branchLevel);
893 |         this.sendToChildren('branchRoot', this.branchRoot);
894 |     }
895 | 
896 |     sendToChildren(type, ...args) {
897 |         Object.keys(this.childPeers).forEach(ip => {
898 |             let child = this.childPeers[ip];
899 |             child.send(type, ...args);
900 |         });
901 |     }
902 | 
903 |     connectToNextParent() {
904 |         if (!this.potentialParents.length) {
905 |             this.client.send('haveNoParent', true);
906 |             this.client.send('acceptChildren', false);
907 |             return;
908 |         }
909 | 
910 |         let nextParent = this.potentialParents.shift();
911 | 
912 |         console.log('trying to connect to parent', nextParent);
913 | 
914 |         this.peerAddresses[nextParent.username] = {
915 |             ip: nextParent.ip,
916 |             port: nextParent.port
917 |         };
918 | 
919 |         this.getPeerByUsername(nextParent.username, 'D', (err, peer) => {
920 |             if (err) {
921 |                 this.emit('error', err);
922 |                 this.connectToNextParent();
923 |                 return;
924 |             }
925 | 
926 |             console.log('successfully connected to parent!');
927 |         });
928 |     }
929 | }
930 | 
931 | module.exports = LiveLook;
932 | 


--------------------------------------------------------------------------------
/lib/blacklist.json:
--------------------------------------------------------------------------------
1 | [
2 |     "beatles",
3 |     "beyonce",
4 |     "chicane saltwater",
5 |     "bob dylan"
6 | ]
7 | 


--------------------------------------------------------------------------------
/lib/build-list.js:
--------------------------------------------------------------------------------
  1 | // create a fileList object for ./messages/file-list
  2 | // pass in a directory and the function will walk through it and build a POJO
  3 | // http://www.museek-plus.org/wiki/SoulseekProtocol#PeerCode5
  4 | 
  5 | const async = require('async');
  6 | const fs = require('fs');
  7 | const mm = require('music-metadata');
  8 | const path = require('path');
  9 | const rr = require('recursive-readdir');
 10 | 
 11 | function getMetaData(file, done) {
 12 |     let found = false;
 13 | 
 14 |     fs.stat(file, (err, stats) => {
 15 |         let populated = { file };
 16 | 
 17 |         if (err) {
 18 |             return done(err);
 19 |         }
 20 | 
 21 |         populated.size = stats.size;
 22 | 
 23 |         mm.parseFile(file)
 24 |             .then(metadata => {
 25 |                 if (found) {
 26 |                     return;
 27 |                 }
 28 | 
 29 |                 found = true;
 30 | 
 31 |                 let vbr = metadata.format.codecProfile;
 32 |                 vbr = vbr ? /v/i.test(vbr) : false;
 33 | 
 34 |                 populated.bitrate = Math.floor(metadata.format.bitrate / 1000);
 35 |                 populated.duration = Math.floor(metadata.format.duration);
 36 |                 populated.vbr = vbr;
 37 |                 done(null, populated);
 38 |             })
 39 |             .catch(err => {
 40 |                 // ignoring because this is likely on a non-media file, and not
 41 |                 // fatal
 42 |                 if (!found) {
 43 |                     done(null, populated);
 44 |                 }
 45 |             });
 46 |     });
 47 | }
 48 | 
 49 | // absolute attribute is enabled for search results. if false, returns an object
 50 | // keys representing directories containing arrays of files. otherwise just
 51 | // returns the array of files
 52 | function buildFileList(files, absolute = true, done) {
 53 |     async.mapSeries(files, getMetaData, (err, files) => {
 54 |         if (err) {
 55 |             return done(err);
 56 |         }
 57 | 
 58 |         let fileList;
 59 | 
 60 |         if (absolute) {
 61 |             fileList = [];
 62 | 
 63 |             for (const file of files) {
 64 |                 const fileExt = path.extname(file.file).slice(1);
 65 | 
 66 |                 fileList.push({
 67 |                     file: file.file,
 68 |                     size: file.size,
 69 |                     extension: fileExt,
 70 |                     bitrate: file.bitrate,
 71 |                     duration: file.duration,
 72 |                     vbr: file.vbr
 73 |                 });
 74 |             }
 75 |         } else {
 76 |             fileList = {};
 77 | 
 78 |             for (const file of files) {
 79 |                 const fileDir = path.dirname(file.file);
 80 |                 const fileName = path.basename(file.file);
 81 |                 const fileExt = path.extname(file.file).slice(1);
 82 | 
 83 |                 if (!fileList[fileDir]) {
 84 |                     fileList[fileDir] = [];
 85 |                 }
 86 | 
 87 |                 fileList[fileDir].push({
 88 |                     file: fileName,
 89 |                     size: file.size,
 90 |                     extension: fileExt,
 91 |                     bitrate: file.bitrate,
 92 |                     duration: file.duration,
 93 |                     vbr: file.vbr
 94 |                 });
 95 |             }
 96 |         }
 97 | 
 98 |         done(null, fileList);
 99 |     });
100 | }
101 | 
102 | function buildShareList(dir, done) {
103 |     rr(dir, (err, files) => {
104 |         if (err) {
105 |             return done(err);
106 |         }
107 | 
108 |         buildFileList(files, false, done);
109 |     });
110 | }
111 | 
112 | module.exports.metaData = getMetaData;
113 | module.exports.files = buildFileList;
114 | module.exports.shares = buildShareList;
115 | 


--------------------------------------------------------------------------------
/lib/check-port.js:
--------------------------------------------------------------------------------
 1 | // confirm our peer server is accepting outside connections
 2 | 
 3 | const http = require('http');
 4 | 
 5 | module.exports = (port, done) => {
 6 |     const url = `http://tools.slsknet.org/porttest.php?port=${port}`;
 7 |     let finished = false;
 8 | 
 9 |     http.get(url, res => {
10 |         let body = '';
11 | 
12 |         res.on('data', data => body += data);
13 | 
14 |         res.on('end', () => {
15 |             body = body.toString();
16 | 
17 |             if (!finished) {
18 |                 finished = true;
19 |                 done(null, body.indexOf(`Port: ${port}/tcp open`) > -1);
20 |             }
21 |         });
22 |     }).on('error', (err) => {
23 |         if (err && !finished) {
24 |             finished = true;
25 |             done(err);
26 |         }
27 |     });
28 | };
29 | 


--------------------------------------------------------------------------------
/lib/client/handlers.js:
--------------------------------------------------------------------------------
  1 | // handle events from soulseek servers
  2 | 
  3 | const DistribPeer = require('../distrib-peer');
  4 | const Peer = require('../peer');
  5 | const TransferPeer = require('../transfer-peer');
  6 | 
  7 | module.exports = (livelook, client) => {
  8 |     const handlers = {
  9 |         error: err => livelook.emit('error', err),
 10 |         getPeerAddress: res => {
 11 |             livelook.peerAddresses[res.username] = {
 12 |                 ip: res.ip,
 13 |                 port: res.port
 14 |             };
 15 | 
 16 |             // remove the peer address after 10 minutes, in case they have
 17 |             // reconnected and changed ips/ports somehow
 18 |             setTimeout(() => {
 19 |                 delete livelook.peerAddresses[res.username];
 20 |             }, 1000 * 60 * 10);
 21 | 
 22 |             livelook.emit('getPeerAddress', res);
 23 |         },
 24 |         joinRoom: res => livelook.rooms[res.room] = res.users,
 25 |         sayChatroom: res => livelook.emit('sayChatroom', res),
 26 |         leaveRoom: res => {
 27 |             livelook.emit('leaveRoom', res.room);
 28 |             delete livelook.rooms[res.room];
 29 |         },
 30 |         userJoinedRoom: res => {
 31 |             let room = livelook.rooms[res.room];
 32 | 
 33 |             if (!room) {
 34 |                 room = [];
 35 |                 livelook.rooms[res.room] = room;
 36 |             }
 37 | 
 38 |             livelook.emit('userJoinedRoom', res);
 39 | 
 40 |             let user = { ...res };
 41 |             delete user.room;
 42 |             room.push(user);
 43 |         },
 44 |         userLeftRoom: res => {
 45 |             let room = livelook.rooms[res.room];
 46 | 
 47 |             if (!room) {
 48 |                 return;
 49 |             }
 50 | 
 51 |             livelook.emit('userLeftRoom', res);
 52 | 
 53 |             let i;
 54 |             for (i = 0; i < room.length; i += 1) {
 55 |                 if (room[i].username === res.username) {
 56 |                     room.splice(i, 1);
 57 |                     break;
 58 |                 }
 59 |             }
 60 |         },
 61 |         // this is sent to us by the server if a peer was unable to directly
 62 |         // connect to our peer server
 63 |         connectToPeer: res => {
 64 |             if (res.cType === 'P') {
 65 |                 if (Object.keys(livelook.peers).length >= this.maxPeers) {
 66 |                     console.log('too many peers!');
 67 |                     return;
 68 |                 }
 69 | 
 70 |                 if (livelook.peers[res.ip]) {
 71 |                     return;
 72 |                 }
 73 | 
 74 |                 // TODO maybe livelook.addPeer
 75 |                 let peer = new Peer(res);
 76 |                 peer.attachHandlers(livelook);
 77 |                 peer.init(() => peer.pierceFirewall());
 78 |             } else if (res.cType === 'F') {
 79 |                 let transferPeer = new TransferPeer(res);
 80 |                 transferPeer.isUpload = res.direction === 1;
 81 |                 transferPeer.attachHandlers(livelook);
 82 |                 transferPeer.init(() => transferPeer.pierceFirewall());
 83 |             } else if (res.cType === 'D') {
 84 |                 console.log('server sent us a D connection', res);
 85 |                 let distribPeer = new DistribPeer(res);
 86 |                 distribPeer.attachHandlers(livelook);
 87 |                 distribPeer.init(() => distribPeer.pierceFirewall());
 88 |             }
 89 | 
 90 |             // TODO lets genericize this a bit more
 91 |         },
 92 |         messageUser: res => {
 93 |             client.send('messageAcked', res.id);
 94 |             livelook.emit('messageUser', res);
 95 |         },
 96 |         relog: () => {
 97 |             livelook.loggedIn = false;
 98 |             livelook.emit('error', new Error('kicked off due to name ' +
 99 |                 'conflict'));
100 |             process.exit(1);
101 |         },
102 |         netInfo: res => {
103 |             console.log('we got netinfo!!! potential parents', res.parents);
104 |             livelook.potentialParents = res.parents;
105 | 
106 |             if (!livelook.parentPeer) {
107 |                 livelook.connectToNextParent();
108 |             }
109 |         },
110 |         roomTickerState: res => {
111 |             livelook.tickers[res.room] = res.users;
112 |             livelook.emit('roomTickerState', res);
113 |         },
114 |         roomTickerAdd: res => {
115 |             try {
116 |                 livelook.tickers[res.room][res.user] = res.ticker;
117 |             } catch (e) {
118 |                 let err = new Error('server sent us a ticker to invalid ' +
119 |                     `room: ${res.room}, username: ${res.username}, ticker: ` +
120 |                     res.ticker);
121 |                 livelook.emit('error', err);
122 |             }
123 | 
124 |             livelook.emit('roomTickerAdd', res);
125 |         },
126 |         roomTickerRemove: res => {
127 |             try {
128 |                 delete livelook.tickers[res.room][res.user];
129 |             } catch (e) {
130 |                 let err = new Error('server told us to delete ticker to ' +
131 |                     `invalid room: ${res.room}, username: ${res.username}`);
132 |                 livelook.emit('error', err);
133 |                 return;
134 |             }
135 | 
136 |             livelook.emit('roomTickerRemove', res);
137 |         },
138 |         cantConnectToPeer: res => {
139 |             livelook.emit('cantConnectToPeer', res);
140 |         }
141 |     };
142 | 
143 |     Object.keys(handlers).forEach(h => client.on(h, handlers[h]));
144 | };
145 | 


--------------------------------------------------------------------------------
/lib/client/index.js:
--------------------------------------------------------------------------------
 1 | // connect to a soulseek server
 2 | 
 3 | const SoulSock = require('../soul-sock');
 4 | const fromServer = require('../message/from-server');
 5 | const toServer = require('../message/to-server');
 6 | const attachHandlers = require('./handlers');
 7 | 
 8 | class Client extends SoulSock {
 9 |     constructor(address) {
10 |         super(address);
11 |         this.encoder = toServer;
12 |         this.decoder = fromServer;
13 |     }
14 | 
15 |     attachHandlers(livelook) {
16 |         attachHandlers(livelook, this);
17 |     }
18 | }
19 | 
20 | module.exports = Client;
21 | 


--------------------------------------------------------------------------------
/lib/distrib-peer/handlers.js:
--------------------------------------------------------------------------------
 1 | module.exports = (livelook, peer) => {
 2 |     const handlers = {
 3 |         error: err => livelook.emit('error', err),
 4 |         connect: () => {
 5 |             if (livelook.parentPeer === null) {
 6 |                 livelook.parentPeer = peer;
 7 |                 console.log('new parent connected');
 8 |                 livelook.refreshParentInfo();
 9 |             } else {
10 |                 console.log('child connected');
11 |                 livelook.childPeers[peer.ip] = peer;
12 |                 // give us some time to send pierceFw
13 |                 setTimeout(() => {
14 |                     peer.send('branchLevel', livelook.branchLevel);
15 |                     peer.send('branchRoot', livelook.branchRoot);
16 |                 }, 100);
17 |             }
18 | 
19 |             livelook.emit('peerConnect', peer);
20 |         },
21 |         close: () => {
22 |             this.connected = false;
23 | 
24 |             if (livelook.parentPeer === peer)  {
25 |                 console.log('our parent disconnected!');
26 |                 livelook.parentPeer = null;
27 |                 livelook.connectToNextParent();
28 |             } else {
29 |                 console.log('one of our children died - no big deal');
30 |                 delete livelook.childPeers[peer.ip];
31 |             }
32 | 
33 |             livelook.emit('peerClose', peer);
34 |         },
35 |         ping: res => {
36 |             if (res.something) {
37 |                 peer.send('ping', res.something);
38 |             } else {
39 |                 peer.send('ping');
40 |             }
41 |         },
42 |         search: res => {
43 |             //console.log('recvd search for ', res.query, ' from ', res.username);
44 |             livelook.respondToPeerSearch(res.username, res.token, res.query,
45 |                 res.something);
46 |         },
47 |         branchRoot: res => {
48 |             if (livelook.parentPeer === peer) {
49 |                 console.log('parent peer sent us a new parent (branch root)', res);
50 |                 livelook.branchRoot = res.root;
51 |                 livelook.client.send('branchRoot', livelook.branchRoot);
52 |                 livelook.sendToChildren('branchRoot', livelook.branchRoot);
53 |             }
54 |         },
55 |         branchLevel: res => {
56 |             if (livelook.parentPeer === peer) {
57 |                 console.log('parent peer sent us a new branch level', res);
58 |                 livelook.branchLevel = res.level;
59 |                 livelook.client.send('branchLevel', livelook.branchLevel);
60 |                 livelook.sendToChildren('branchLevel', livelook.branchLevel);
61 |             }
62 |         }
63 |     };
64 | 
65 |     Object.keys(handlers).forEach(h => peer.on(h, handlers[h]));
66 | };
67 | 


--------------------------------------------------------------------------------
/lib/distrib-peer/index.js:
--------------------------------------------------------------------------------
  1 | const EventEmitter = require('events').EventEmitter;
  2 | const MessageEmitter = require('../message/emitter');
  3 | const attachHandlers = require('./handlers');
  4 | const fromDistrib = require('../message/from-distrib');
  5 | const net = require('net');
  6 | const toDistrib = require('../message/to-distrib');
  7 | 
  8 | // TODO make soulsock a little more generic and extend that
  9 | 
 10 | class DistribPeer extends EventEmitter {
 11 |     constructor(args) {
 12 |         super();
 13 | 
 14 |         if (args.constructor && args.constructor.name === 'Socket') {
 15 |             this.socket = args;
 16 |             this.ip = this.socket.remoteAddress.replace('::ffff:', '');
 17 |             this.port = this.socket.remotePort;
 18 |         } else {
 19 |             this.username = args.username;
 20 |             this.ip = args.ip;
 21 |             this.port = args.port;
 22 |             this.socket = new net.Socket();
 23 |         }
 24 | 
 25 |         this.token = args.token;
 26 | 
 27 |         this.messages = new MessageEmitter();
 28 |         this.connected = false;
 29 | 
 30 |         let length;
 31 | 
 32 |         this.socket.on('error', err => this.emit('error', err));
 33 | 
 34 |         this.messages.on('message', message => {
 35 |             let size = message.int32();
 36 | 
 37 |             if (!size) {
 38 |                 return;
 39 |             }
 40 | 
 41 |             let code = message.int8();
 42 | 
 43 |             let decoded;
 44 | 
 45 |             try {
 46 |                 decoded = fromDistrib[code](message);
 47 |             } catch (e) {
 48 |                 e.packet = message;
 49 |                 this.emit('error', e);
 50 |                 return;
 51 |             }
 52 | 
 53 |             if (decoded.type !== 'search') {
 54 |                 console.log('distrib ', this.ip, 'recvd', JSON.stringify(decoded));
 55 |             }
 56 |             this.emit(decoded.type, decoded);
 57 |         });
 58 |     }
 59 | 
 60 |     sendMessage(message) {
 61 |         if (this.connected) {
 62 |             this.socket.write(message.getBuff());
 63 |         }
 64 |     }
 65 | 
 66 |     send(type, ...args) {
 67 |         let factory = toDistrib[type];
 68 | 
 69 |         if (!factory) {
 70 |             throw new Error(`no message factory for ${type}`);
 71 |         }
 72 | 
 73 |         console.log(this.constructor.name, 'sending', type, JSON.stringify(args));
 74 |         this.sendMessage(factory.apply(null, args));
 75 |     }
 76 | 
 77 |     attachHandlers(livelook) {
 78 |         attachHandlers(livelook, this);
 79 |     }
 80 | 
 81 |     pierceFirewall() {
 82 |         console.log('pierce fw with token', this.token);
 83 |         this.send('pierceFirewall', this.token);
 84 |     }
 85 | 
 86 |     init(done) {
 87 |         this.socket.pipe(this.messages);
 88 | 
 89 |         // we're already connected
 90 |         if (this.socket.bytesRead) {
 91 |             this.emit('connect');
 92 |             done();
 93 |             return;
 94 |         }
 95 | 
 96 |         this.socket.connect({
 97 |             host: this.ip,
 98 |             port: this.port
 99 |         }, () => {
100 |             this.connected = true;
101 |             this.emit('connect');
102 | 
103 |             if (done) {
104 |                 done();
105 |             }
106 |         });
107 |     }
108 | }
109 | 
110 | module.exports = DistribPeer;
111 | 


--------------------------------------------------------------------------------
/lib/make-token.js:
--------------------------------------------------------------------------------
1 | const crypto = require('crypto');
2 | //module.exports = () => crypto.randomBytes(4).toString('hex');
3 | //module.exports = () => crypto.randomBytes(4).readInt32LE(0);
4 | module.exports = () => Math.floor(Math.random() * 2147483647);
5 | 


--------------------------------------------------------------------------------
/lib/message/decode-list.js:
--------------------------------------------------------------------------------
 1 | const Message = require('./index');
 2 | const zlib = require('zlib');
 3 | 
 4 | function decodeFiles(packet) {
 5 |     let files = [];
 6 | 
 7 |     let fileCount = packet.int32();
 8 | 
 9 |     for (let i = 0; i < fileCount; i += 1) {
10 |         let unused = packet.int8();
11 | 
12 |         let file = {
13 |             file: packet.str(),
14 |             size: packet.int64(),
15 |             extension: packet.str()
16 |         };
17 | 
18 |         let attrs = [];
19 |         let attrCount = packet.int32();
20 | 
21 |         for (let j = 0; j < attrCount; j += 1) {
22 |             packet.int32(); // position in attribute
23 |             attrs.push(packet.int32());
24 |         }
25 | 
26 |         // bitrate is always first
27 |         if (attrs.length) {
28 |             file.bitrate = attrs[0];
29 |         }
30 | 
31 |         if (attrs.length === 3) {
32 |             // sometimes the vbr indicator is in third position
33 |             if (attrs[2] === 0 || attrs[2] === 1) {
34 |                 file.vbr = attrs[2] === 1;
35 |                 file.duration = attrs[1];
36 |             // sometimes the vbr indicator is in second position
37 |             } else if (attrs[1] === 0 || attrs[1] === 1) {
38 |                 files.vbr = attrs[1] === 1;
39 |                 file.duration = attrs[2];
40 |             }
41 |         } else if (attrs.length === 2) {
42 |             // sometimes the vbr indicator is in second position
43 |             if (attrs[1] === 0 || attrs[1] === 1) {
44 |                 // if it's a vbr file we can't deduce the length
45 |                 file.vbr = attrs[1];
46 |                 // if it's a constant bitrate we can deduce the length.
47 |                 if (file.vbr) {
48 |                     // dividing the file size by the bitrate in bytes should
49 |                     // give us a good enough approximation
50 |                     file.duration = file.size / (file.bitrate / 8 * 1000);
51 |                 }
52 |             // sometimes the bitrate is in first position and the length in
53 |             // second position
54 |             } else {
55 |                 file.duration = attrs[1];
56 |             }
57 |         }
58 | 
59 |         files.push(file);
60 |     }
61 | 
62 |     return files;
63 | }
64 | 
65 | function decodeShares(packet, compressed = true) {
66 |     let dirs = {};
67 | 
68 |     let unzipped;
69 | 
70 |     if (compressed) {
71 |         unzipped = packet.data.slice(packet.pointer, packet.data.length);
72 |         // TODO we have to do this with async
73 |         unzipped = new Message(zlib.inflateSync(unzipped));
74 |     } else {
75 |         unzipped = packet;
76 |     }
77 | 
78 |     let dirCount = unzipped.int32();
79 |     for (let i = 0; i < dirCount; i += 1) {
80 |         let dirName = unzipped.str().replace(/\\/g, '/');
81 |         dirs[dirName] = decodeFiles(unzipped);
82 |     }
83 | 
84 |     return dirs;
85 | }
86 | 
87 | module.exports.files = decodeFiles;
88 | module.exports.shares = decodeShares;
89 | 


--------------------------------------------------------------------------------
/lib/message/decode-room.js:
--------------------------------------------------------------------------------
 1 | function decodeJoinRoom(msg) {
 2 |     let decoded = { type: 'joinRoom', room: msg.str(), users: [] };
 3 | 
 4 |     let userCount = msg.int32();
 5 |     for (let i = 0; i < userCount; i += 1) {
 6 |         decoded.users.push({ username: msg.str() });
 7 |     }
 8 | 
 9 |     // this should be the same...
10 |     msg.int32();
11 | 
12 |     for (let i = 0; i < userCount; i += 1) {
13 |         decoded.users[i].status = msg.int32();
14 |     }
15 | 
16 |     msg.int32();
17 | 
18 |     for (let i = 0; i < userCount; i += 1) {
19 |         decoded.users[i].speed = msg.int32();
20 |         decoded.users[i].downloadNum = msg.int64();
21 |         decoded.users[i].files = msg.int32();
22 |         decoded.users[i].folders = msg.int32();
23 |     }
24 | 
25 |     msg.int32();
26 | 
27 |     for (let i = 0; i < userCount; i += 1) {
28 |         decoded.users[i].slotsFree = msg.int32();
29 |     }
30 | 
31 |     msg.int32();
32 | 
33 |     for (let i = 0; i < userCount; i += 1) {
34 |         decoded.users[i].country = msg.str();
35 |     }
36 | 
37 |     let owner;
38 | 
39 |     try {
40 |         owner = msg.str();
41 |     } catch (e) {
42 |         owner = null;
43 |     }
44 | 
45 |     if (owner) {
46 |         decoded.owner = owner;
47 | 
48 |         let operatorCount = msg.int32();
49 |         for (let i = 0; i < operatorCount; i += 1) {
50 |             let operator = msg.str();
51 | 
52 |             decoded.users = decoded.users.map(user => {
53 |                 if (user.username === operator) {
54 |                     user.operator = true;
55 |                 }
56 |             });
57 |         }
58 |     }
59 | 
60 |     return decoded;
61 | }
62 | 
63 | function decodeRoomChunk(msg) {
64 |     let rooms = [];
65 | 
66 |     let roomCount = msg.int32();
67 |     for (let i = 0; i < roomCount; i += 1) {
68 |         rooms.push({ name: msg.str() });
69 |     }
70 | 
71 |     msg.int32(); // user count
72 | 
73 |     for (let i = 0; i < roomCount; i += 1) {
74 |         rooms[i].users = msg.int32();
75 |     }
76 | 
77 |     return rooms;
78 | }
79 | 
80 | function decodeRoomList(msg) {
81 |     return {
82 |         type: 'roomList',
83 |         'public': decodeRoomChunk(msg),
84 |         ownedPrivate: decodeRoomChunk(msg),
85 |         'private': decodeRoomChunk(msg)
86 |     };
87 | }
88 | 
89 | module.exports.join = decodeJoinRoom;
90 | module.exports.list = decodeRoomList;
91 | 


--------------------------------------------------------------------------------
/lib/message/emitter.js:
--------------------------------------------------------------------------------
 1 | // parse packets out of partial or concatenated streams of data
 2 | 
 3 | const Message = require('./index');
 4 | const stream = require('stream');
 5 | 
 6 | class MessageEmitter extends stream.Writable {
 7 |     _write(chunk, enc, next) {
 8 |         this.read(this.rest ? Buffer.concat([this.rest, chunk]) : chunk);
 9 |         next();
10 |     }
11 | 
12 |     read(data) {
13 |         if (data.length < 4) {
14 |             this.rest = data.slice(0, data.length);
15 |             return;
16 |         }
17 | 
18 |         let size = data.readUInt32LE();
19 | 
20 |         if (size + 4 <= data.length) {
21 |             this.emit('message', new Message(data.slice(0, size + 4)));
22 |             this.read(data.slice(size + 4, data.length));
23 |         } else {
24 |             this.rest = data.slice(0, data.length);
25 |         }
26 |     }
27 | 
28 |     reset() {
29 |         this.rest = undefined;
30 |     }
31 | }
32 | 
33 | module.exports = MessageEmitter;
34 | 


--------------------------------------------------------------------------------
/lib/message/encode-list.js:
--------------------------------------------------------------------------------
 1 | const Message = require('./index');
 2 | const zlib = require('zlib');
 3 | 
 4 | function encodeFiles(packet, fileList) {
 5 |     packet.int32(fileList.length);
 6 | 
 7 |     for (let file of fileList) {
 8 |         packet.int8(1);
 9 |         packet.str(file.file);
10 |         packet.int64(file.size);
11 |         packet.str(file.extension);
12 | 
13 |         let attrs = [];
14 | 
15 |         if (file.bitrate) {
16 |             attrs.push(file.bitrate);
17 | 
18 |             if (file.duration) {
19 |                 attrs.push(file.duration);
20 |                 // don't push vbr flag unless we also have duration - deliberate
21 |                 attrs.push(file.vbr);
22 |             }
23 |         }
24 | 
25 |         packet.int32(attrs.length);
26 |         attrs.forEach((attr, i) => {
27 |             packet.int32(i);
28 |             packet.int32(attr);
29 |         });
30 |     }
31 | }
32 | 
33 | // http://www.museek-plus.org/wiki/SoulseekProtocol#PeerCode5
34 | function encodeShares(packet, shareList, compress = true) {
35 |     let dirs = Object.keys(shareList);
36 |     let compressed = new Message();
37 | 
38 |     compressed.int32(dirs.length);
39 | 
40 |     for (let dir of dirs) {
41 |         compressed.str(dir.replace(/\//g, '\\'));
42 |         encodeFiles(compressed, shareList[dir]);
43 |     }
44 | 
45 |     if (compress) {
46 |         compressed = zlib.deflateSync(compressed.data);
47 |     }
48 | 
49 |     packet.writeBuffer(compressed);
50 | }
51 | 
52 | module.exports.files = encodeFiles;
53 | module.exports.shares = encodeShares;
54 | 


--------------------------------------------------------------------------------
/lib/message/from-distrib.js:
--------------------------------------------------------------------------------
 1 | module.exports = {
 2 |     0: msg => {
 3 |         let decoded = { type: 'ping' };
 4 | 
 5 |         if (msg.length >= 4) {
 6 |             decoded.something = msg.int32();
 7 |         }
 8 | 
 9 |         return decoded;
10 |     },
11 |     3: msg => ({
12 |         type: 'search',
13 |         something: msg.int32(),
14 |         username: msg.str(),
15 |         token: msg.int32(),
16 |         query: msg.str()
17 |     }),
18 |     4: msg => ({
19 |         type: 'branchLevel',
20 |         level: msg.int32()
21 |     }),
22 |     5: msg => ({
23 |         type: 'branchRoot',
24 |         root: msg.str()
25 |     }),
26 |     7: msg => ({
27 |         type: 'childDepth',
28 |         depth: msg.int32()
29 |     })
30 | };
31 | 


--------------------------------------------------------------------------------
/lib/message/from-peer.js:
--------------------------------------------------------------------------------
  1 | // peer -> client packet decoders
  2 | 
  3 | const Message = require('./');
  4 | const decodeList = require('./decode-list');
  5 | const zlib = require('zlib');
  6 | 
  7 | module.exports = {
  8 |     0: msg => ({
  9 |         type: 'pierceFirewall',
 10 |         token: msg.int32()
 11 |     }),
 12 |     1: msg => ({
 13 |         type: 'peerInit',
 14 |         username: msg.str(),
 15 |         cType: msg.str(),
 16 |         token: msg.int32()
 17 |     }),
 18 |     4: msg => ({ type: 'getShareFileList' }),
 19 |     5: msg => ({ type: 'sharedFileList', fileList: decodeList.shares(msg) }),
 20 |     8: msg => ({
 21 |         type: 'fileSearchRequest',
 22 |         token: msg.int32(),
 23 |         query: msg.str()
 24 |     }),
 25 |     9: msg => {
 26 |         let unzipped = msg.data.slice(msg.pointer, msg.data.length);
 27 |         // TODO move this to the decoder and make this async
 28 |         unzipped = new Message(zlib.inflateSync(unzipped));
 29 | 
 30 |         return {
 31 |             type: 'fileSearchResult',
 32 |             username: unzipped.str(),
 33 |             token: unzipped.int32(),
 34 |             fileList: decodeList.files(unzipped),
 35 |             slotsFree: !!unzipped.int8(),
 36 |             speed: unzipped.int32(),
 37 |             queueSize: unzipped.int64()
 38 |         };
 39 |     },
 40 |     15: () => ({ type: 'userInfoRequest' }),
 41 |     16: msg => {
 42 |         let decoded = {
 43 |             type: 'userInfoReply',
 44 |             description: msg.str()
 45 |         };
 46 | 
 47 |         let hasPicture = msg.int8();
 48 | 
 49 |         if (hasPicture) {
 50 |             decoded.picture = msg.file();
 51 |         }
 52 | 
 53 |         decoded.totalUpload = msg.int32();
 54 |         decoded.queueSize = msg.int32();
 55 |         decoded.slotsFree = msg.int8();
 56 | 
 57 |         return decoded;
 58 |     },
 59 |     // this might be unofficial, but nicotine supports it!
 60 |     22: msg => {
 61 |         let decoded = {
 62 |             type: 'messageUser',
 63 |             id: msg.int32(),
 64 |             timestamp: new Date(msg.int32() * 1000),
 65 |             username: msg.str(),
 66 |             message: msg.str()
 67 |         };
 68 | 
 69 |         try {
 70 |             decoded.isAdmin = !!msg.int8();
 71 |         } catch (e) {
 72 |             decoded.isAdmin = false;
 73 |         }
 74 | 
 75 |         return decoded;
 76 |     },
 77 |     36: msg => {
 78 |         let decoded = {
 79 |             type: 'folderContentsRequest',
 80 |             dirs: []
 81 |         };
 82 | 
 83 |         let fileCount = msg.int32();
 84 |         for (let i = 0; i < fileCount; i += 1) {
 85 |             decoded.dirs.push(msg.str());
 86 |         }
 87 | 
 88 |         return decoded;
 89 |     },
 90 |     37: msg => {
 91 |         let decoded = {
 92 |             type: 'folderContentsResponse',
 93 |             requests: {}
 94 |         };
 95 | 
 96 |         let unzipped = msg.data.slice(msg.pointer, msg.length);
 97 |         unzipped = new Message(zlib.inflateSync(unzipped));
 98 | 
 99 |         let dirRequests = unzipped.int32();
100 | 
101 |         for (let i = 0; i < dirRequests; i += 1) {
102 |             decoded.requests[unzipped.str()] = decodeList.shares(unzipped, false);
103 |         }
104 | 
105 |         return decoded;
106 |     },
107 |     40: msg => {
108 |         let decoded = {
109 |             type: 'transferRequest',
110 |             direction: msg.int32(),
111 |             token: msg.int32(),
112 |             file: msg.str()
113 |         };
114 | 
115 |         if (decoded.direction) {
116 |             decoded.size = msg.int64();
117 |         }
118 | 
119 |         return decoded;
120 |     },
121 |     41: msg => {
122 |         let decoded = {
123 |             type: 'transferResponse',
124 |             token: msg.int32(),
125 |             allowed: !!msg.int8()
126 |         };
127 | 
128 |         if (decoded.allowed) {
129 |             decoded.size = msg.int64();
130 |         } else {
131 |             decoded.reason = msg.str();
132 |         }
133 | 
134 |         return decoded;
135 |     },
136 |     43: msg => ({ type: 'queueUpload', file: msg.str() }),
137 |     44: msg => ({ type: 'placeInQueue', file: msg.str(), place: msg.int32() }),
138 |     46: msg => ({ type: 'uploadFailed', file: msg.str() }),
139 |     50: msg => ({ type: 'queueFailed', file: msg.str(), reason: msg.str() }),
140 |     51: msg => ({ type: 'placeInQueueRequest', file: msg.str() }),
141 |     52: () => ({ type: 'uploadQueueNotification' })
142 | };
143 | 


--------------------------------------------------------------------------------
/lib/message/from-server.js:
--------------------------------------------------------------------------------
  1 | // server -> client packet decoders
  2 | 
  3 | const decodeRoom = require('./decode-room');
  4 | 
  5 | module.exports = {
  6 |     1: msg => {
  7 |         let decoded = { type: 'login', success: msg.int8() };
  8 |         decoded[decoded.success ? 'motd' : 'reason'] = msg.str();
  9 |         return decoded;
 10 |     },
 11 |     3: msg => ({
 12 |         type: 'getPeerAddress',
 13 |         username: msg.str(),
 14 |         ip: msg.ipAddr(),
 15 |         port: msg.int32()
 16 |     }),
 17 |     5: msg => {
 18 |         let decoded = {
 19 |             type: 'addUser',
 20 |             username: msg.str(),
 21 |             exists: msg.int8()
 22 |         };
 23 | 
 24 |         if (decoded.exists) {
 25 |             decoded.status = msg.int32();
 26 |             decoded.speed = msg.int32();
 27 |             // TODO not sure what this is
 28 |             decoded.downloadNum = msg.int32();
 29 |             decoded.files = msg.int32();
 30 |             decoded.folders = msg.int32();
 31 |             // may not be implemented
 32 |             try {
 33 |                 decoded.country = msg.str();
 34 |             } catch (e) {
 35 |                 // discard
 36 |             }
 37 |         }
 38 | 
 39 |         return decoded;
 40 |     },
 41 |     7: msg => ({
 42 |         type: 'getUserStatus',
 43 |         username: msg.str(),
 44 |         status: msg.int32(),
 45 |         privileged: msg.int8()
 46 |     }),
 47 |     13: msg => ({
 48 |         type: 'sayChatroom',
 49 |         room: msg.str(),
 50 |         username: msg.str(),
 51 |         message: msg.str()
 52 |     }),
 53 |     14: decodeRoom.join,
 54 |     15: msg => ({
 55 |         type: 'leaveRoom',
 56 |         room: msg.str()
 57 |     }),
 58 |     16: msg => ({
 59 |         type: 'userJoinedRoom',
 60 |         room: msg.str(),
 61 |         username: msg.str(),
 62 |         status: msg.int32(),
 63 |         speed: msg.int32(),
 64 |         downloadNum: msg.int64(),
 65 |         files: msg.int32(),
 66 |         folders: msg.int32(),
 67 |         slotsFree: msg.int32(),
 68 |         country: msg.str()
 69 |     }),
 70 |     17: msg => ({
 71 |         type: 'userLeftRoom',
 72 |         room: msg.str(),
 73 |         username: msg.str()
 74 |     }),
 75 |     18: msg => ({
 76 |         type: 'connectToPeer',
 77 |         username: msg.str(),
 78 |         cType: msg.str(),
 79 |         ip: msg.ipAddr(),
 80 |         port: msg.int32(),
 81 |         token: msg.int32(),
 82 |         privileged: msg.int8()
 83 |     }),
 84 |     22: msg => {
 85 |         let decoded = {
 86 |             type: 'messageUser',
 87 |             id: msg.int32(),
 88 |             timestamp: new Date(msg.int32() * 1000),
 89 |             username: msg.str(),
 90 |             message: msg.str()
 91 |         };
 92 | 
 93 |         try {
 94 |             decoded.isAdmin = !!msg.int8();
 95 |         } catch (e) {
 96 |             decoded.isAdmin = false;
 97 |         }
 98 | 
 99 |         return decoded;
100 |     },
101 |     26: msg => {
102 |         return {
103 |             type: 'fileSearch',
104 |             username: msg.str(),
105 |             query: msg.str()
106 |         };
107 |     },
108 |     32: () => ({ type: 'ping' }),
109 |     // this is apparently deprecated, but it's still being sent to us
110 |     36: msg => ({
111 |         type: 'getUserStats',
112 |         username: msg.str(),
113 |         speed: msg.int32(),
114 |         downloadNum: msg.int64(),
115 |         files: msg.int32(),
116 |         directories: msg.int32()
117 |     }),
118 |     41: () => ({ type: 'relog' }),
119 |     54: msg => {
120 |         let decoded = {
121 |             type: 'globalRecommendations',
122 |             recommendations: [],
123 |             unrecommendations: []
124 |         };
125 | 
126 |         let recCount = msg.int32();
127 |         for (let i = 0; i < recCount; i += 1) {
128 |             decoded.recommendations.push({
129 |                 name: msg.str(),
130 |                 count: msg.int32()
131 |             });
132 |         }
133 | 
134 |         let unrecCount = msg.int32();
135 |         for (let i = 0; i < unrecCount; i += 1) {
136 |             decoded.unrecommendations.push({
137 |                 name: msg.str(),
138 |                 count: msg.int32()
139 |             });
140 |         }
141 | 
142 |         return decoded;
143 |     },
144 |     57: msg => {
145 |         let decoded = { type: 'userInterests', liked: [], hated: [] };
146 | 
147 |         let likedCount = msg.int32();
148 |         for (let i = 0; i < likedCount; i += 1) {
149 |             decoded.liked.push(msg.str());
150 |         }
151 | 
152 |         let hatedCount = msg.int32();
153 |         for (let i = 0; i < hatedCount; i += 1) {
154 |             decoded.hated.push(msg.str());
155 |         }
156 | 
157 |         return decoded;
158 |     },
159 |     64: decodeRoom.list,
160 |     69: msg => {
161 |         let decoded = { type: 'privilegedUsers', users: [] };
162 | 
163 |         let userCount = msg.int32();
164 |         for (let i = 0; i < userCount; i += 1) {
165 |             decoded.users.push(msg.str());
166 |         }
167 | 
168 |         return decoded;
169 |     },
170 |     83: msg => ({ type: 'parentMinSpeed', minSpeed: msg.int32() }),
171 |     84: msg => ({ type: 'parentSpeedRatio', ratio: msg.int32() }),
172 |     91: msg => ({ type: 'addToPrivileged', username: msg.str() }),
173 |     92: msg => ({ type: 'checkPrivileges', timeLeft: msg.int32() }),
174 |     93: msg => ({
175 |         type: 'searchRequest',
176 |         distributedCode: msg.int8(),
177 |         unknown: msg.int32(),
178 |         username: msg.str(),
179 |         token: msg.int32(),
180 |         query: msg.str()
181 |     }),
182 |     102: msg => {
183 |         let decoded = { type: 'netInfo', parents: [] };
184 | 
185 |         let parentCount = msg.int32();
186 | 
187 |         for (let i = 0; i < parentCount; i += 1) {
188 |             decoded.parents.push({
189 |                 username: msg.str(),
190 |                 ip: msg.ipAddr(),
191 |                 port: msg.int32()
192 |             });
193 |         }
194 | 
195 |         return decoded;
196 |     },
197 |     104: msg => ({ type: 'wishlistInterval', interval: msg.int32() }),
198 |     110: msg => {
199 |         let decoded = { type: 'similarUsers', users: [] };
200 | 
201 |         let userCount = msg.int32();
202 |         for (let i = 0; i < userCount; i += 1) {
203 |             decoded.users.push({
204 |                 username: msg.str(),
205 |                 status: msg.int32()
206 |             });
207 |         }
208 | 
209 |         return decoded;
210 |     },
211 |     111: msg => {
212 |         let decoded = {
213 |             type: 'itemRecommendations',
214 |             item: msg.str(),
215 |             recommendations: []
216 |         };
217 | 
218 |         let recCount = msg.int32();
219 |         for (let i = 0; i < recCount; i += 1) {
220 |             decoded.recommendations.push({
221 |                 name: msg.str(),
222 |                 count: msg.int32()
223 |             });
224 |         }
225 | 
226 |         return decoded;
227 |     },
228 |     112: msg => {
229 |         let decoded = {
230 |             type: 'itemSimilarUsers',
231 |             item: msg.str(),
232 |             users: []
233 |         };
234 | 
235 |         let userCount = msg.int32();
236 |         for (let i = 0; i < userCount; i += 1) {
237 |             decoded.users.push({ username: msg.str(), count: msg.int32() });
238 |         }
239 | 
240 |         return decoded;
241 |     },
242 |     113: msg => {
243 |         let decoded = {
244 |             type: 'roomTickerState',
245 |             room: msg.str(),
246 |             users: {}
247 |         };
248 | 
249 |         let userCount = msg.int32();
250 |         for (let i = 0; i < userCount; i += 1) {
251 |             // TODO make sure this isn't reversed - this is how nicotine does it
252 |             decoded.users[msg.str()] = msg.str();
253 |         }
254 | 
255 |         return decoded;
256 |     },
257 |     114: msg => ({
258 |         type: 'roomTickerAdd',
259 |         room: msg.str(),
260 |         username: msg.str(),
261 |         ticker: msg.str()
262 |     }),
263 |     115: msg => ({
264 |         type: 'roomTickerRemove',
265 |         room: msg.str(),
266 |         username: msg.str(),
267 |     }),
268 |     125: msg => ({ type: 'ackNotifyPrivileges', token: msg.int32() }),
269 |     // members we can alter in a private room
270 |     133: msg => {
271 |         let decoded = {
272 |             type: 'privateRoomUsers',
273 |             users: []
274 |         };
275 | 
276 |         let userCount = msg.int32();
277 |         for (let i = 0; i < userCount; i += 1) {
278 |             decoded.users.push(msg.str());
279 |         }
280 | 
281 |         return decoded;
282 |     },
283 |     134: msg => ({
284 |         type: 'privateRoomAddUser',
285 |         room: msg.str(),
286 |         username: msg.str()
287 |     }),
288 |     135: msg => ({
289 |         type: 'privateRoomRemoveUser',
290 |         room: msg.str(),
291 |         username: msg.str()
292 |     }),
293 |     139: msg => ({ type: 'privateRoomAdded', room: msg.str() }),
294 |     140: msg => ({ type: 'privateRoomRemoved', room: msg.str() }),
295 |     141: msg => ({ type: 'privateRoomToggle', enable: msg.int8() }),
296 |     142: msg => ({ type: 'changePassword', password: msg.str() }),
297 |     143: msg => ({
298 |         type: 'privateRoomAddOperator',
299 |         room: msg.str(),
300 |         username: msg.str()
301 |     }),
302 |     144: msg => ({
303 |         type: 'privateRoomRemoveOperator',
304 |         room: msg.str(),
305 |         username: msg.str()
306 |     }),
307 |     145: msg => ({ type: 'privateRoomOperatorAdded', room: msg.str() }),
308 |     146: msg => ({ type: 'privateRoomOperatorRemoved', room: msg.str() }),
309 |     148: msg => {
310 |         let decoded = {
311 |             type: 'privateRoomOwned',
312 |             room: msg.str(),
313 |             operators: []
314 |         };
315 | 
316 |         let opCount = msg.int32();
317 |         for (let i = 0; i < 0; i += 1) {
318 |             decoded.operators.push(msg.str());
319 |         }
320 | 
321 |         return decoded;
322 |     },
323 |     152: msg => ({
324 |         type: 'publicChat',
325 |         room: msg.str(),
326 |         username: msg.str(),
327 |         message: msg.str()
328 |     }),
329 |     1001: msg => ({ type: 'cantConnectToPeer', token: msg.int32() })
330 | };
331 | 


--------------------------------------------------------------------------------
/lib/message/index.js:
--------------------------------------------------------------------------------
  1 | // handle packet construction and reading
  2 | // http://www.museek-plus.org/wiki/SoulseekProtocol#Packing
  3 | 
  4 | const Uint64LE = require('int64-buffer').Uint64LE;
  5 | 
  6 | class Message {
  7 |     constructor(buffer) {
  8 |         if (buffer) {
  9 |             this.data = buffer;
 10 |             this.write = false;
 11 |         } else {
 12 |             this.data = Buffer.alloc(0);
 13 |             this.write = true;
 14 |         }
 15 | 
 16 |         this.pointer = 0;
 17 |     }
 18 | 
 19 |     int8(val) {
 20 |         return this.write ? this.write8(val) : this.read8();
 21 |     }
 22 | 
 23 |     int32(val) {
 24 |         return this.write ? this.write32(val) : this.read32();
 25 |     }
 26 | 
 27 |     sInt32(val) {
 28 |         return this.write ? this.writeS32(val) : this.readS32();
 29 |     }
 30 | 
 31 |     int64(val) {
 32 |         return this.write ? this.write64(val) : this.read64();
 33 |     }
 34 | 
 35 |     str(val) {
 36 |         return this.write ? this.writeStr(val) : this.readStr();
 37 |     }
 38 | 
 39 |     file(val) {
 40 |         return this.write ? this.writeFile(val) : this.readFile();
 41 |     }
 42 | 
 43 |     rawHexStr(val) {
 44 |         return this.write ? this.writeRawHexStr(val) : this.readRawHexStr(val);
 45 |     }
 46 | 
 47 |     ipAddr(val) {
 48 |         return this.write ? this.writeIpAddr(val) : this.readIpAddr();
 49 |     }
 50 | 
 51 |     size() {
 52 |         return this.data.length;
 53 |     }
 54 | 
 55 |     seek(val) {
 56 |         this.pointer += val;
 57 |     }
 58 | 
 59 |     write8(val) {
 60 |         let b = Buffer.alloc(1);
 61 |         b.writeUInt8(val, 0);
 62 |         this.data = Buffer.concat([this.data, b]);
 63 |         this.pointer += 1;
 64 |         return this;
 65 |     }
 66 | 
 67 |     write32(val) {
 68 |         let b = Buffer.alloc(4);
 69 |         b.writeUInt32LE(val, 0);
 70 |         this.data = Buffer.concat([this.data, b]);
 71 |         this.pointer += 4;
 72 |         return this;
 73 |     }
 74 | 
 75 |     writeS32(val) {
 76 |         let b = Buffer.alloc(4);
 77 |         b.writeInt32LE(val, 0);
 78 |         this.data = Buffer.concat([this.data, b]);
 79 |         this.pointer += 4;
 80 |         return this;
 81 |     }
 82 | 
 83 |     write64(val) {
 84 |         let b = Uint64LE(val).toBuffer();
 85 |         this.data = Buffer.concat([this.data, b]);
 86 |         this.pointer += 8;
 87 |         return this;
 88 |     }
 89 | 
 90 |     writeStr(val) {
 91 |         // convert to buff
 92 |         let b = Buffer.from(val, 'utf8');
 93 |         let s = Buffer.alloc(4);
 94 |         s.writeUInt32LE(b.length, 0);
 95 | 
 96 |         // write length
 97 |         b = Buffer.concat([s, b]);
 98 | 
 99 |         // write text
100 |         this.data = Buffer.concat([this.data, b]);
101 |         this.pointer += b.length;
102 |         return this;
103 |     }
104 | 
105 |     writeFile(val) {
106 |         // convert to buff
107 |         let b = Buffer.from(val, 'utf8');
108 |         let s = Buffer.alloc(4);
109 |         s.writeUInt32LE(b.length, 0);
110 | 
111 |         // write length
112 |         b = Buffer.concat([s, b]);
113 | 
114 |         // write file
115 |         this.data = Buffer.concat([this.data, b]);
116 |         this.pointer += b.length;
117 |         return this;
118 |     }
119 | 
120 |     writeRawHexStr(val) {
121 |         let b = Buffer.from(val, 'hex');
122 |         this.data = Buffer.concat([this.data, b]);
123 |         this.pointer += b.length;
124 |         return this;
125 |     }
126 | 
127 |     writeBuffer(buff) {
128 |         this.data = Buffer.concat([this.data, buff]);
129 |         this.pointer += buff.length;
130 |         return this;
131 |     }
132 | 
133 |     writeIpAddr(ip) {
134 |         ip = Array.isArray(ip) ? ip : ip.split('.');
135 |         ip.forEach(num => this.int8(num));
136 |         return this;
137 |     }
138 | 
139 |     read8() {
140 |         let val = this.data.readUInt8(this.pointer);
141 |         this.pointer += 1;
142 |         return val;
143 |     }
144 | 
145 |     read32() {
146 |         let val = this.data.readUInt32LE(this.pointer);
147 |         this.pointer += 4;
148 |         return val;
149 |     }
150 | 
151 |     readS32() {
152 |         let val = this.data.readInt32LE(this.pointer);
153 |         this.pointer += 4;
154 |         return val;
155 |     }
156 | 
157 |     read64() {
158 |         let val = Uint64LE(this.data.slice(this.pointer, this.pointer + 8));
159 |         this.pointer += 8;
160 |         return val;
161 |     }
162 | 
163 |     readStr() {
164 |         let size = this.data.readUInt32LE(this.pointer);
165 |         this.pointer += 4;
166 | 
167 |         let str = this.data.toString('utf8', this.pointer, this.pointer + size);
168 |         this.pointer += size;
169 |         return str;
170 |     }
171 | 
172 |     // read the embedded image files
173 |     readFile() {
174 |         let size = this.data.readUInt32LE(this.pointer);
175 |         this.pointer += 4;
176 | 
177 |         let buff = this.data.slice(this.pointer, this.pointer + size);
178 |         this.pointer += size;
179 |         return buff;
180 |     }
181 | 
182 |     readRawHexStr(size) {
183 |         let str = this.data.toString('hex', this.pointer, this.pointer + size);
184 |         this.pointer += size;
185 |         return str;
186 |     }
187 | 
188 |     readIpAddr() {
189 |         let ip = [];
190 | 
191 |         for (let i = 0; i < 4; i += 1) {
192 |             ip.push(this.read8());
193 |         }
194 | 
195 |         return ip.reverse().join('.');
196 |     }
197 | 
198 |     // this shud b toBuffer() TODO
199 |     getBuff() {
200 |         const b = Buffer.alloc(4);
201 |         b.writeUInt32LE(this.data.length, 0);
202 |         this.data = Buffer.concat([b, this.data]);
203 |         this.write = false;
204 |         return this.data;
205 |     }
206 | }
207 | 
208 | module.exports = Message;
209 | 


--------------------------------------------------------------------------------
/lib/message/to-distrib.js:
--------------------------------------------------------------------------------
 1 | const Message = require('./index');
 2 | const toPeer = require('./to-peer');
 3 | 
 4 | module.exports = {
 5 |     pierceFirewall: toPeer.pierceFirewall,
 6 |     peerInit: toPeer.peerInit,
 7 |     ping: something => {
 8 |         let msg = new Message().int8(0);
 9 | 
10 |         if (something) {
11 |             msg.int32(something);
12 |         }
13 | 
14 |         return msg;
15 |     },
16 |     search: args => {
17 |         var msg = new Message().int8(3).int32(args.something || 0);
18 |         msg.str(args.username).int32(args.token).str(args.query);
19 |         return msg;
20 |     },
21 |     branchLevel: level => new Message().int8(4).int32(level),
22 |     branchRoot: root => new Message().int8(5).int32(root),
23 |     childDepth: depth => new Message().int8(8).int32(depth)
24 | };
25 | 


--------------------------------------------------------------------------------
/lib/message/to-peer.js:
--------------------------------------------------------------------------------
  1 | // client -> peer packet factories
  2 | 
  3 | const Message = require('./index');
  4 | const encodeList = require('./encode-list');
  5 | const zlib = require('zlib');
  6 | 
  7 | module.exports = {
  8 |     pierceFirewall: token => new Message().int8(0).int32(token),
  9 |     peerInit: (username, cType, token) => {
 10 |         return new Message().int8(1).str(username).str(cType).int32(token)
 11 |     },
 12 |     // request a list of files
 13 |     getShareFileList: () => new Message().int32(4),
 14 |     sharedFileList: shareList => {
 15 |         let msg = new Message().int32(5);
 16 |         encodeList.shares(msg, shareList);
 17 |         return msg;
 18 |     },
 19 |     // send this to the peer when we search for something
 20 |     fileSearchRequest: (token, query) => {
 21 |         return new Message().int32(8).int32(token).str(query);
 22 |     },
 23 |     fileSearchResult: args => {
 24 |         let msg = new Message().str(args.username).int32(args.token);
 25 |         encodeList.files(msg, args.fileList);
 26 |         msg.int8(args.slotsFree).int32(args.speed).int64(args.queueSize);
 27 |         return new Message().int32(9).writeBuffer(zlib.deflateSync(msg.data));
 28 |     },
 29 |     userInfoRequest: () => new Message().int32(15),
 30 |     userInfoReply: args => {
 31 |         let msg = new Message().int32(16).str(args.description);
 32 | 
 33 |         if (args.picture) {
 34 |             msg.int8(true).file(args.picture);
 35 |         } else {
 36 |             msg.int8(false);
 37 |         }
 38 | 
 39 |         msg.int32(args.uploadSlots).int32(args.queueSize).int8(args.slotsFree);
 40 |         // who we accept uploads from
 41 |         msg.int32(args.uploadsFrom);
 42 | 
 43 |         return msg;
 44 |     },
 45 |     messageAcked: () => new Message().int32(23),
 46 |     folderContentsRequest: folders => {
 47 |         folders = Array.isArray(folders) ? folders : [ folders ];
 48 |         let msg = new Message().int32(36).int32(folders.length);
 49 |         folders.forEach(folder => msg.str(folder));
 50 |         return msg;
 51 |     },
 52 |     folderContentsResponse: shareLists => {
 53 |         let zipped = new Message();
 54 | 
 55 |         zipped.int32(Object.keys(fileLists).length);
 56 | 
 57 |         Object.keys(fileLists).forEach(dir => {
 58 |             encodeList.shares(zipped, shareLists[dir], false);
 59 |         });
 60 | 
 61 |         zipped = zlib.deflateSync(zipped.data);
 62 | 
 63 |         let msg = new Message().int32(37)
 64 |         msg.writeBuffer(zlib.deflateSync(zipped.data));
 65 |         return msg;
 66 |     },
 67 |     transferRequest: (isUpload, token, file, size) => {
 68 |         let msg = new Message().int32(40);
 69 |         msg.int32(+isUpload); // direction 1 for upload
 70 |         msg.int32(token).str(file);
 71 | 
 72 |         if (isUpload) {
 73 |             msg.int64(size);
 74 |         }
 75 | 
 76 |         return msg;
 77 |     },
 78 |     transferResponse: (token, allowed, size) => {
 79 |         let msg = new Message().int32(41).int32(token);
 80 | 
 81 |         if (allowed) {
 82 |             msg.int8(true).int64(size);
 83 |         } else {
 84 |             msg.int8(false).str(size); // reason
 85 |         }
 86 | 
 87 |         return msg;
 88 |     },
 89 |     queueUpload: file => new Message().int32(43).str(file),
 90 |     placeInQueue: (file, place) => {
 91 |         return new Message().int32(44).str(file).int32(place);
 92 |     },
 93 |     uploadFailed: file => new Message().int32(46).str(file),
 94 |     queueFailed: (file, reason) => {
 95 |         return new Message().int32(50).str(file).str(reason);
 96 |     },
 97 |     // TODO may not need this
 98 |     placeInQueueRequest: file => new Message().int32(51).str(file)
 99 | };
100 | 


--------------------------------------------------------------------------------
/lib/message/to-server.js:
--------------------------------------------------------------------------------
  1 | // client -> server packet factories
  2 | 
  3 | const Message = require('./index');
  4 | const crypto = require('crypto');
  5 | 
  6 | const VERSION = 157;
  7 | const MINOR = 17;
  8 | 
  9 | module.exports = {
 10 |     login: (username, password) => {
 11 |         let hash = crypto.createHash('md5').update(username + password);
 12 |         hash = hash.digest('hex');
 13 |         let msg = new Message().int32(1).str(username).str(password);
 14 |         msg.int32(VERSION).str(hash).int32(MINOR);
 15 |         return msg;
 16 |     },
 17 |     setWaitPort: port => new Message().int32(2).int32(port),
 18 |     getPeerAddress: username => new Message().int32(3).str(username),
 19 |     addUser: username => new Message().int32(5).str(username),
 20 |     getUserStatus: username => new Message().int32(7).str(username),
 21 |     sayChatroom: (room, message) => {
 22 |         return new Message().int32(13).str(room).str(message);
 23 |     },
 24 |     joinRoom: room => new Message().int32(14).str(room),
 25 |     leaveRoom: room => new Message().int32(15).str(room),
 26 |     connectToPeer: (token, username, type) => {
 27 |         return new Message().int32(18).int32(token).str(username).str(type);
 28 |     },
 29 |     messageUser: (username, message) => {
 30 |         return new Message().int32(22).str(username).str(message);
 31 |     },
 32 |     messageAcked: id => new Message().int32(23).int32(id),
 33 |     fileSearch: (token, query) => {
 34 |         return new Message().int32(26).int32(token).str(query);
 35 |     },
 36 |     setStatus: online => new Message().int32(28).int32(online ? 2 : 1),
 37 |     ping: () => new Message().int32(32),
 38 |     sharedFoldersFiles: (folderCount, fileCount) => {
 39 |         return new Message().int32(35).int32(folderCount).int32(fileCount);
 40 |     },
 41 |     userSearch: (username, token, query) => {
 42 |         return new Message().int32(42).int32(token).str(query);
 43 |     },
 44 |     addThingILike: item => new Message().int32(51).str(item),
 45 |     removeThingILike: item => new Message().int32(52).str(item),
 46 |     recommendations: () => new Message().sInt32(54),
 47 |     globalRecommendations: () => new Message().sInt32(56),
 48 |     userInterests: username => new Message().int32(57).str(username),
 49 |     roomList: () => new Message().int32(57).str(username),
 50 |     privilegedUsers: () => new Message().int32(69),
 51 |     haveNoParent: haveParent => new Message().int32(71).int8(haveParent),
 52 |     parentIp: ip => new Message().int32(73).ipAddr(ip),
 53 |     checkPrivileges: () => new Message().int32(92),
 54 |     acceptChildren: accept => new Message().int32(100).int8(accept),
 55 |     wishlistSearch: (token, query) => {
 56 |         return new Message().int32(103).int32(token).str(query);
 57 |     },
 58 |     similarUsers: () => new Message().int32(110),
 59 |     itemRecommendations: item => new Message().sInt32(111).str(item),
 60 |     itemSimilarUsers: item => new Message().int32(112).str(item),
 61 |     roomTickerSet: (room, ticker) => {
 62 |         return new Message().int32(117).str(room).str(ticker);
 63 |     },
 64 |     addThingIHate: item => new Message().int32(118).str(item),
 65 |     removeThingIHate: item => new Message().int32(119).str(item),
 66 |     roomSearch: (room, token, query) => {
 67 |         return new Message().int32(120).int32(token).str(query);
 68 |     },
 69 |     sendUploadSpeed: speed => new Message().int32(121).int32(speed),
 70 |     // give (part) of your privileges to another user on the network
 71 |     givePrivileges: (username, days) => {
 72 |         return new Message().int32(123).str(username).int32(days);
 73 |     },
 74 |     notifyPrivileges: (token, username) => {
 75 |         return new Message().int32(124).int32(token).str(username);
 76 |     },
 77 |     ackNotifyPrivileges: () => new Message().int32(125),
 78 |     branchLevel: level => new Message().int32(126).int32(level),
 79 |     branchRoot: root => new Message().int32(127).str(root),
 80 |     childDepth: depth => new Message().int32(129).int32(depth),
 81 |     privateRoomAddUser: (room, username) => {
 82 |         return new Message().int32(134).str(room).str(username);
 83 |     },
 84 |     privateRoomRemoveUser: (room, username) => {
 85 |         return new Message().int32(135).str(room).str(username);
 86 |     },
 87 |     privateRoomDismember: room => new Message().int32(136).str(room),
 88 |     privateRoomDisown: room => new Message().int32(137).str(room),
 89 |     // send this when we want to enable or disable invitations to private rooms
 90 |     privateRoomToggle: enable => new Message().int32(141).str(enable),
 91 |     changePassword: password => new Message().int32(142).str(password),
 92 |     privateRoomAddOperator: (room, username) => {
 93 |         return new Message().int32(143).str(room).str(username);
 94 |     },
 95 |     privateRoomRemoveOperator: (room, username) => {
 96 |         return new Message().int32(144).str(room).str(username);
 97 |     },
 98 |     // broadcast a message to multiple users
 99 |     messageUsers: (usernames, message) => {
100 |         let msg = new Message().int32(149).int32(usernames.length);
101 |         usernames.forEach(username => msg.str(username));
102 |         msg.str(message);
103 |         return msg;
104 |     },
105 |     // ask the server to send us all public chats
106 |     // ie every single line written in every public room
107 |     askPublicChat: () => new Message().int32(150),
108 |     stopPublicChat: () => new Message().int32(151),
109 |     cantConnectToPeer: (token, username) => {
110 |         return new Message().int32(1001).int32(token).str(username);
111 |     }
112 | };
113 | 


--------------------------------------------------------------------------------
/lib/nat-pmp-map.js:
--------------------------------------------------------------------------------
 1 | const natpmp = require('nat-pmp');
 2 | const network = require('network');
 3 | 
 4 | // TODO add a timer that automatically re-opens a port once ttl runs out
 5 | // also unmap ports on process.exit
 6 | 
 7 | module.exports = function (done) {
 8 |     network.get_gateway_ip((err, gateway) => {
 9 |         if (err) {
10 |             this.emit('error', err);
11 |             return done(err);
12 |         }
13 | 
14 |         let natpmpClient = natpmp.connect(gateway);
15 |         natpmpClient.on('error', error => this.emit('error', err));
16 | 
17 |         let natpmpTimeout = setTimeout(() => {
18 |             natpmpClient.close();
19 |             let err = new Error('unable to connect to nat-pmp. try enabling ' +
20 |                 `upnp or forward port ${this.port} at http://${gateway}`);
21 |             this.emit('error', err);
22 |             done(err);
23 |         }, 5000);
24 | 
25 |         natpmpClient.portMapping({
26 |             private: this.port,
27 |             public: this.port,
28 |             ttl: 3600 // TODO obv increase this
29 |         }, (err, res) => {
30 |             clearTimeout(natpmpTimeout);
31 |             natpmpClient.close();
32 | 
33 |             if (!err) {
34 |                 this.pmp = res;
35 |                 this.emit('waitPort', this.pmp.public);
36 |             }
37 | 
38 |             done(err);
39 |         });
40 |     });
41 | };
42 | 


--------------------------------------------------------------------------------
/lib/peer-server.js:
--------------------------------------------------------------------------------
  1 | // listen for other peer connections
  2 | 
  3 | const EventEmitter = require('events').EventEmitter;
  4 | const Message = require('./message');
  5 | const MessageEmitter = require('./message/emitter');
  6 | const DistribPeer = require('./distrib-peer');
  7 | const Peer = require('./peer');
  8 | const callbackify = require('util').callbackify;
  9 | const checkPort = require('./check-port');
 10 | const fromPeer = require('./message/from-peer');
 11 | const getPort = callbackify(require('get-port'));
 12 | const natPmpMap = require('./nat-pmp-map');
 13 | const net = require('net');
 14 | 
 15 | class PeerServer extends EventEmitter {
 16 |     constructor(args, livelook) {
 17 |         super();
 18 | 
 19 |         this.port = args.port || 2234;
 20 |         this.maxPeers = args.maxPeers || 100;
 21 |         this.livelook = livelook; // :(
 22 | 
 23 |         this.server = new net.Server();
 24 |         this.pmp = {};
 25 |         this.listening = false;
 26 |         //this.peers = {};
 27 | 
 28 |         this.server.on('close', () => {
 29 |             this.emit('close');
 30 |             this.listening = false;
 31 |         });
 32 | 
 33 |         this.server.on('listening', () => {
 34 |             console.log('peer server is listening on port ' + this.port);
 35 |             this.emit('listening');
 36 |             this.listening = true;
 37 |         });
 38 | 
 39 |         this.incomingData = Buffer.alloc(0);
 40 | 
 41 |         this.server.on('connection', socket => {
 42 |             // TODO check for banned IPs
 43 | 
 44 |             let errorListener = err => this.emit('error', err);
 45 |             socket.on('error', errorListener);
 46 | 
 47 |             let length;
 48 | 
 49 |             let dataListener = data => {
 50 |                 this.incomingData = Buffer.concat([this.incomingData, data]);
 51 |                 //console.log(this.incomingData);
 52 | 
 53 |                 if (!length && this.incomingData.length >= 4) {
 54 |                     length = this.incomingData.readUInt32LE(0);
 55 |                     this.incomingData = this.incomingData.slice(4);
 56 |                 }
 57 | 
 58 |                 if (this.incomingData.length >= length) {
 59 |                     // remove old event listeners because peer has its own
 60 |                     socket.removeListener('data', dataListener);
 61 |                     socket.removeListener('error', errorListener);
 62 | 
 63 |                     let id = this.incomingData[0];
 64 |                     console.log('peer server client id', id);
 65 |                     let message = new Message(this.incomingData.slice(1));
 66 | 
 67 |                     let decoded;
 68 | 
 69 |                     try {
 70 |                         decoded = fromPeer[id](message);
 71 |                     } catch (e) {
 72 |                         e.packet = message;
 73 |                         this.emit('error', e);
 74 |                         return;
 75 |                     }
 76 | 
 77 |                     if (decoded.type === 'pierceFirewall') {
 78 |                         console.log('peer server client sent us a pierce firewall');
 79 |                         let cType = livelook.pendingPeers[decoded.token];
 80 | 
 81 |                         if (!cType) {
 82 |                             console.log('peer tried to connect to us without us sending req');
 83 |                             cType = 'P';
 84 |                         }
 85 | 
 86 |                         // TODO peer limit
 87 | 
 88 |                         let peer;
 89 | 
 90 |                         if (cType === 'P') {
 91 |                             peer = new Peer(socket);
 92 |                         } else if (cType === 'D') {
 93 |                             peer = new DistribPeer(socket);
 94 |                         }
 95 | 
 96 |                         peer.connected = true;
 97 |                         peer.token = decoded.token;
 98 |                         peer.attachHandlers(this.livelook);
 99 | 
100 |                         peer.init(() => {
101 |                             // this is probably not optional here
102 |                             peer.pierceFirewall();
103 | 
104 |                             let nextData = this.incomingData.slice(length);
105 |                             peer.socket.emit('data', nextData);
106 |                         });
107 |                     } else if (decoded.type === 'peerInit') {
108 |                         if (decoded.cType === 'F') {
109 |                             // TODO TransferPeer
110 |                             console.log('TODO bring TransferPeer');
111 |                             return;
112 |                         }
113 | 
114 |                         let peer;
115 | 
116 |                         if (decoded.cType === 'P') {
117 |                             peer = new Peer(socket);
118 |                         } else if (decoded.cType === 'D') {
119 |                             peer = new DistribPeer(socket);
120 |                             console.log('potentially a child');
121 |                         }
122 | 
123 |                         peer.connected = true;
124 |                         peer.token = decoded.token;
125 |                         peer.username = decoded.username;
126 |                         peer.attachHandlers(this.livelook);
127 | 
128 |                         peer.init(() => {
129 |                             // this might be optional here
130 |                             peer.pierceFirewall();
131 |                             // the next message is usually stuck to the initial
132 |                             // buffer, so we can re-send it to make sure our
133 |                             // message emitter reads it
134 |                             let nextData = this.incomingData.slice(length);
135 |                             peer.socket.emit('data', nextData);
136 |                         });
137 |                     }
138 |                 }
139 |             };
140 | 
141 |             socket.on('data', dataListener);
142 |         });
143 | 
144 |         this.server.on('error', err => this.emit('error', err));
145 |     }
146 | 
147 |     natPmpMap(done) {
148 |         natPmpMap.bind(this)((err, res) => {
149 |             if (err) {
150 |                 this.emit('error', err);
151 |                 return done(err);
152 |             }
153 | 
154 |             this.server.listen(this.pmp.private, () => {
155 |                 checkPort(this.port, (err, open) => {
156 |                     if (err) {
157 |                         done(err);
158 |                         this.emit('error', err);
159 |                     } else if (!open) {
160 |                         let err = new Error('we used pmp but soulseek ' +
161 |                             'still can\'t see us');
162 |                         this.emit('error', err);
163 |                         done(err);
164 |                     } else {
165 |                         done();
166 |                     }
167 |                 });
168 |             });
169 |         });
170 |     }
171 | 
172 |     init(done) {
173 |         getPort({ port: this.port }, (err, port) => {
174 |             if (err) {
175 |                 this.emit('error', err);
176 |                 return done(err);
177 |             }
178 | 
179 |             this.port = port;
180 |             this.emit('waitPort', this.port);
181 | 
182 |             let listenTimeout = setTimeout(() => {
183 |                 let err = new Error('timed out with peer server listen');
184 |                 this.emit('error', err);
185 |                 done(err);
186 |             }, 5000);
187 | 
188 |             // TODO if connect finishes afer the setTimeout, done might get
189 |             // called again
190 | 
191 |             this.server.listen(this.port, () => {
192 |                 clearTimeout(listenTimeout);
193 | 
194 |                 checkPort(this.port, (err, open) => {
195 |                     if (err) {
196 |                         done(err);
197 |                     } else if (!open) {
198 |                         this.server.close();
199 |                         this.natPmpMap(done);
200 |                     } else {
201 |                         done();
202 |                     }
203 |                 });
204 |             });
205 |         });
206 |     }
207 | }
208 | 
209 | module.exports = PeerServer;
210 | 


--------------------------------------------------------------------------------
/lib/peer/handlers.js:
--------------------------------------------------------------------------------
  1 | // handle events from P type peers
  2 | 
  3 | const TransferPeer = require('../transfer-peer');
  4 | const path = require('path');
  5 | const toPeer = require('../message/to-peer');
  6 | const makeToken = require('../make-token');
  7 | 
  8 | module.exports = (livelook, peer) => {
  9 |     const handlers = {
 10 |         error: err => {
 11 |             err.peer = peer;
 12 |             livelook.emit('error', err)
 13 |         },
 14 |         connect: () => {
 15 |             this.connected = true;
 16 |             livelook.peers[peer.ip] = peer;
 17 |             livelook.emit('peerConnect', peer);
 18 |         },
 19 |         close: () => {
 20 |             this.connected = false;
 21 |             delete livelook.peers[peer.ip];
 22 |             livelook.emit('peerClose', peer);
 23 |         },
 24 |         getShareFileList: () => peer.send('sharedFileList', livelook.shareList),
 25 |         sharedFileList: res => {
 26 |             livelook.emit('sharedFileList', { peer, shareList: res });
 27 |         },
 28 |         fileSearchResult: res => {
 29 |             res.peer = peer;
 30 |             delete res.type;
 31 |             livelook.emit('fileSearchResult', res);
 32 |         },
 33 |         userInfoRequest: () => {
 34 |             peer.send('userInfoReply', {
 35 |                 description: livelook.description,
 36 |                 picture: livelook.picture,
 37 |                 uploadSlots: livelook.uploadSlots,
 38 |                 queueSize: 0,
 39 |                 slotsFree: !Object.keys(livelook.uploads).length,
 40 |                 uploadsAllowed: 0 // who we allow upload from
 41 |             });
 42 |         },
 43 |         userInfoReply: res => {
 44 |             res.peer = peer;
 45 |             delete res.type;
 46 |             livelook.emit('userInfoReply', res);
 47 |         },
 48 |         folderContentsRequest: res => {
 49 |             let response = {};
 50 | 
 51 |             for (let dir of res.dirs) {
 52 |                 let ourDir = this.shareList[dir];
 53 | 
 54 |                 if (ourDir) {
 55 |                     response[dir] = { dir: ourDir };
 56 |                 }
 57 |             }
 58 | 
 59 |             peer.send('folderContentsResponse', response);
 60 |         },
 61 |         folderContentsResponse: res => {
 62 |             res.peer = peer;
 63 |             delete res.type;
 64 |             livelook.emit('folderContentsResponse', res);
 65 |         },
 66 |         // this is nonstandard but nicotine supports it
 67 |         messageUser: res => {
 68 |             peer.send('messageAcked', res.id);
 69 |             livelook.emit('messageUser', res);
 70 |         },
 71 |         transferRequest: res => {
 72 |             // somebody wants to download (we are uploading)
 73 |             if (res.direction === 0) {
 74 |                 let file = livelook.getSharedFile(res.file);
 75 | 
 76 |                 console.log('getting xfer req for ', res.file);
 77 | 
 78 |                 if (!file) {
 79 |                     console.log(res.file, 'not found for xfer');
 80 |                     return;
 81 |                 }
 82 | 
 83 |                 let dir = res.file.replace(/\\/g, '/');
 84 |                 dir = path.dirname(dir);
 85 |                 let upload = { file, dir, peer };
 86 | 
 87 |                 // nicotine doesn't even do this
 88 |                 if (livelook.isTransferring(upload, true)) {
 89 |                     console.log(res.file, 'were alrdy xfering it');
 90 |                     return;
 91 |                 }
 92 | 
 93 |                 let queuePos = livelook.getUploadQueuePos(upload);
 94 | 
 95 |                 if (queuePos > -1) {
 96 |                     peer.send('transferResponse', res.token, false, 'Queued');
 97 |                     return;
 98 |                 }
 99 | 
100 |                 let inProgress = Object.keys(livelook.uploads).length;
101 | 
102 |                 if (inProgress >= livelook.uploadSlots) {
103 |                     let queueLength = livelook.uploadQueue.push({
104 |                         ...upload, token: res.token
105 |                     });
106 | 
107 |                     peer.send('transferResponse', res.token, false, 'Queued');
108 |                     peer.send('placeInQueue', res.file, queueLength);
109 | 
110 |                     livelook.emit('queueUpload', {
111 |                         token: res.token,
112 |                         upload,
113 |                         position: queueLength
114 |                     });
115 | 
116 |                     return;
117 |                 }
118 | 
119 |                 livelook.uploads[res.token] = upload;
120 |                 peer.send('transferResponse', res.token, true, file.size);
121 |                 livelook.emit('startUpload', { token: res.token, upload });
122 |             } else {
123 |                 console.log(Object.keys(livelook.toDownload));
124 |                 let download = livelook.toDownload[res.file];
125 | 
126 |                 if (!download) {
127 |                     return;
128 |                 }
129 | 
130 |                 // TODO check download slots
131 |                 livelook.downloads[res.token] = download;
132 |                 delete livelook.toDownload[res.file]
133 |                 peer.send('transferResponse', res.token, true);
134 | 
135 |                 // TODO this is copypastad
136 |                 let transferPeer = new TransferPeer({
137 |                     ip: download.peer.ip,
138 |                     port: download.peer.port,
139 |                     isUpload: false
140 |                 });
141 | 
142 |                 transferPeer.fileToken = res.token;
143 |                 transferPeer.fileStart = download.fileStart;
144 |                 transferPeer.fileSize = res.size;
145 |                 transferPeer.attachHandlers(livelook);
146 | 
147 |                 transferPeer.init(() => {
148 |                     transferPeer.peerInit(livelook.username);
149 |                     transferPeer.sendFileToken(res.token);
150 |                     transferPeer.sendFileStart();
151 |                     livelook.emit('startDownload', {
152 |                         token: res.token,
153 |                         download
154 |                     });
155 |                 });
156 |             }
157 |         },
158 |         // a peer sends us this after we send them a transfer request for an
159 |         // upload or download
160 |         transferResponse: res => {
161 |             let upload = livelook.uploads[res.token];
162 |             let download = livelook.downloads[res.token];
163 |             let transfer = upload || download;
164 |             let isUpload = !!upload;
165 | 
166 |             if (!res.allowed) {
167 |                 // the user had sent an earlier transferResponse accepting
168 |                 // this file, but changed their mind
169 |                 if (transfer && /cancel/i.test(res.reason)) {
170 |                     transfer.peer.socket.destroy();
171 | 
172 |                     if (isUpload) {
173 |                         delete livelook.uploads[res.token];
174 |                     } else {
175 |                         delete livelook.downloads[res.token];
176 |                     }
177 | 
178 |                     return;
179 |                 }
180 | 
181 |                 // we sent a download request, the user declined
182 |                 // but put us in their queue
183 |                 if (transfer && /queue/i.test(res.reason)) {
184 |                     let fileName = transfer.dir.replace(/\//g, '\\');
185 |                     fileName += '\\' + transfer.file;
186 |                     livelook.toDownload[fileName] = transfer;
187 |                     delete livelook.downloads[res.token];
188 |                     console.log('denied download but placed in queue', res);
189 |                     livelook.emit('queueDownload', {
190 |                         token: res.token,
191 |                         download: transfer
192 |                     });
193 |                 }
194 | 
195 |                 return;
196 |             }
197 | 
198 |             if (!transfer) {
199 |                 return;
200 |             }
201 | 
202 |             if (isUpload) {
203 | 				// the F connection
204 | 				let transferPeer = new TransferPeer({
205 | 					ip: transfer.peer.ip,
206 | 					port: transfer.peer.port,
207 | 				});
208 | 
209 | 				transferPeer.fileToken = res.token;
210 | 				transferPeer.attachHandlers(livelook);
211 | 				transferPeer.init(() => {
212 | 					// TODO check to see when we need to send pierceFirewall
213 | 					transferPeer.peerInit(livelook.username);
214 | 					transferPeer.sendFileToken();
215 | 				});
216 |             } else {
217 | 				// the F connection
218 | 				let transferPeer = new TransferPeer({
219 | 					ip: transfer.peer.ip,
220 | 					port: transfer.peer.port,
221 |                     isUpload: false
222 | 				});
223 | 
224 |                 transferPeer.fileToken = res.token;
225 |                 transferPeer.fileStart = transfer.fileStart;
226 |                 transferPeer.fileSize = res.size;
227 | 				transferPeer.attachHandlers(livelook);
228 | 
229 |                 transferPeer.init(() => {
230 |                     transferPeer.peerInit(livelook.username);
231 |                     transferPeer.sendFileToken(res.token);
232 |                     transferPeer.sendFileStart();
233 |                     livelook.emit('startDownload', {
234 |                         token: res.token,
235 |                         download
236 |                     });
237 |                 });
238 |             }
239 |         },
240 |         queueUpload: res => {
241 |             let file = livelook.getSharedFile(res.file);
242 | 
243 |             if (!file) {
244 |                 return;
245 |             }
246 | 
247 |             let dir = res.file.replace(/\\/g, '/');
248 |             dir = path.dirname(dir);
249 |             let upload = { file, dir, peer };
250 | 
251 |             if (livelook.isTransferring(upload, true)) {
252 |                 return;
253 |             }
254 | 
255 |             let queuePos = livelook.getUploadQueuePos(upload);
256 | 
257 |             if (queuePos > -1) {
258 |                 return peer.send('placeInQueue', res.file, queuePos);
259 |             }
260 | 
261 |             let inProgress = Object.keys(livelook.uploads).length;
262 | 
263 |             if (inProgress >= livelook.uploadSlots) {
264 |                 let queueLength = livelook.uploadQueue.push({
265 |                     ...upload, token: res.token
266 |                 });
267 | 
268 |                 return peer.send('placeInQueue', res.file, queueLength);
269 |             }
270 | 
271 |             let token = makeToken();
272 |             livelook.uploads[token] = upload;
273 |             peer.send('transferRequest', 1, token, res.file, file.size);
274 |             livelook.emit('startUpload', { token: token, upload });
275 |             // TODO we should move startUpload to the xfer peer maybe
276 |         }
277 |     };
278 | 
279 |     Object.keys(handlers).forEach(h => peer.on(h, handlers[h]));
280 | };
281 | 


--------------------------------------------------------------------------------
/lib/peer/index.js:
--------------------------------------------------------------------------------
 1 | // a direct connection to another user
 2 | 
 3 | const SoulSock = require('../soul-sock');
 4 | const fromPeer = require('../message/from-peer');
 5 | const toPeer = require('../message/to-peer');
 6 | const attachHandlers = require('./handlers');
 7 | 
 8 | class Peer extends SoulSock {
 9 |     constructor(args) {
10 |         super(args);
11 |         this.encoder = toPeer;
12 |         this.decoder = fromPeer;
13 | 
14 |         this.username = args.username;
15 |         this.token = args.token;
16 |     }
17 | 
18 |     attachHandlers(livelook) {
19 |         attachHandlers(livelook, this);
20 |     }
21 | 
22 |     pierceFirewall() {
23 |         this.send('pierceFirewall', this.token);
24 |     }
25 | }
26 | 
27 | module.exports = Peer;
28 | 


--------------------------------------------------------------------------------
/lib/search-share-list.js:
--------------------------------------------------------------------------------
 1 | // find a query in our sharelist
 2 | 
 3 | const path = require('path');
 4 | 
 5 | // format files into a flattened array with strings suitable for searching
 6 | function formatShareList(shareList) {
 7 |     let flattened = [];
 8 | 
 9 |     Object.keys(shareList).forEach(dir => {
10 |         shareList[dir].forEach(file => {
11 |             dir = dir.replace(/\//g, '\\');
12 |             let formatted = dir + ' ';
13 |             formatted += file.file.replace(path.extname(file.file), '');
14 |             formatted = formatted.replace(/[\/\-_]/g, ' ');
15 |             formatted = formatted.replace(/[^0-9a-z ]/gi, '').toLowerCase();
16 |             flattened.push({ dir, file, formatted });
17 |         });
18 |     });
19 | 
20 |     return flattened;
21 | }
22 | 
23 | function searchShareList(shareList, query, limit = 50) {
24 |     query = query.toLowerCase().replace(/[\/\-_]/g, ' ');
25 |     query = query.replace(/[^0-9a-z ]/gi, '').toLowerCase().trim();
26 | 
27 |     if (query.length < 3) {
28 |         return [];
29 |     }
30 | 
31 |     let found = [];
32 |     let formatted = formatShareList(shareList);
33 |     let terms = query.split(' ');
34 | 
35 |     // ok so it's not actually a pair anymore
36 |     formatted.forEach(filePair => {
37 |         let formatted = filePair.formatted;
38 | 
39 |         for (let term of terms) {
40 |             if (formatted.indexOf(term) === -1) {
41 |                 return;
42 |             }
43 |         }
44 | 
45 |         found.push({
46 |             file: filePair.dir + '\\' + filePair.file.file,
47 |             size: filePair.file.size,
48 |             extension: filePair.file.extension,
49 |             bitrate: filePair.file.bitrate,
50 |             duration: filePair.file.duration,
51 |             vbr: filePair.file.vbr
52 |         });
53 |     });
54 | 
55 |     // TODO instead of slicing we should break a for loop
56 |     return found.slice(0, limit);
57 | }
58 | 
59 | 
60 | module.exports.search = searchShareList;
61 | 


--------------------------------------------------------------------------------
/lib/soul-sock.js:
--------------------------------------------------------------------------------
  1 | // base class between client and peer
  2 | 
  3 | const EventEmitter = require('events').EventEmitter;
  4 | const MessageEmitter = require('./message/emitter');
  5 | const net = require('net');
  6 | 
  7 | class SoulSock extends EventEmitter {
  8 |     constructor(args) {
  9 |         super();
 10 | 
 11 |         if (args.constructor && args.constructor.name === 'Socket') {
 12 |             this.socket = args;
 13 |             this.ip = this.socket.remoteAddress.replace('::ffff:', '');
 14 |             this.port = this.socket.remotePort;
 15 |         } else {
 16 |             this.ip = args.ip;
 17 |             this.port = args.port;
 18 |             this.socket = new net.Socket();
 19 |         }
 20 | 
 21 |         this.messages = new MessageEmitter();
 22 |         this.connected = false;
 23 |     }
 24 | 
 25 |     sendMessage(message) {
 26 |         if (this.connected) {
 27 |             this.socket.write(message.getBuff());
 28 |         }
 29 |     }
 30 | 
 31 |     send(type, ...args) {
 32 |         let factory = this.encoder[type];
 33 | 
 34 |         if (!factory) {
 35 |             throw new Error(`no message factory for ${type}`);
 36 |         }
 37 | 
 38 |         console.log(this.constructor.name, 'sending', type, JSON.stringify(args));
 39 |         this.sendMessage(factory.apply(null, args));
 40 |     }
 41 | 
 42 |     init(done) {
 43 |         done = done || (() => {});
 44 | 
 45 |         this.socket.on('close', () => this.emit('close'));
 46 |         this.socket.on('error', err => this.emit('error', err));
 47 | 
 48 |         this.messages.on('message', message => {
 49 |             let size = message.int32();
 50 | 
 51 |             if (size < 4) {
 52 |                 return;
 53 |             }
 54 | 
 55 |             let code = message.int32();
 56 |             let decoded = this.decoder[code]; // fromPeer, fromServer
 57 | 
 58 |             try {
 59 |                 decoded = decoded ? decoded(message) : null;
 60 |             } catch (e) {
 61 |                 e.packet = message;
 62 |                 this.emit('error', e);
 63 |             }
 64 | 
 65 |             if (!decoded) {
 66 |                 let err = new Error(`unknown message id ${code}`);
 67 |                 err.packet = message;
 68 |                 this.emit('error', err);
 69 |             } else {
 70 |                 let recvd = JSON.stringify(decoded);
 71 | 
 72 |                 if (recvd && recvd.length <= 500) {
 73 |                     console.log(this.constructor.name, 'recevied', recvd);
 74 |                 } else {
 75 |                     console.log(this.constructor.name, 'recevied', decoded.type, 'but it\'s too darn long');
 76 |                 }
 77 | 
 78 |                 this.emit(decoded.type, decoded);
 79 |             }
 80 |         });
 81 | 
 82 |         this.socket.pipe(this.messages);
 83 | 
 84 |         // we're already connected
 85 |         if (this.socket.bytesRead) {
 86 |             this.emit('connect');
 87 |             done();
 88 |             return;
 89 |         }
 90 | 
 91 |         this.socket.connect({
 92 |             host: this.ip,
 93 |             port: this.port
 94 |         }, () => {
 95 |             this.connected = true;
 96 |             this.emit('connect');
 97 |             done();
 98 |         });
 99 |     }
100 | }
101 | 
102 | module.exports = SoulSock;
103 | 


--------------------------------------------------------------------------------
/lib/transfer-peer/handlers.js:
--------------------------------------------------------------------------------
 1 | const fs = require('fs');
 2 | const makeToken = require('../make-token');
 3 | const net = require('net');
 4 | const toPeer = require('../message/to-peer');
 5 | 
 6 | module.exports = (livelook, peer) => {
 7 |     const handlers = {
 8 |         error: err => livelook.emit('error', err),
 9 |         close: () => {
10 |             let isUpload = !!livelook.uploads[peer.fileToken];
11 | 
12 |             if (isUpload) {
13 |                 livelook.emit('endUpload', {
14 |                     token: peer.fileToken,
15 |                     upload: livelook.uploads[peer.fileToken]
16 |                 });
17 | 
18 |                 delete livelook.uploads[peer.fileToken];
19 | 
20 |                 let nextUpload = livelook.uploadQueue.shift();
21 | 
22 |                 if (!nextUpload) {
23 |                     return;
24 |                 }
25 | 
26 |                 let token = nextUpload.token;
27 |                 delete nextUpload.token;
28 | 
29 |                 let file = nextUpload.dir.replace(/\//g, '\\') + '\\';
30 |                 file += nextUpload.file.file;
31 |                 let size = nextUpload.file.size;
32 | 
33 |                 livelook.uploads[token] = nextUpload;
34 |                 nextUpload.peer.send('transferRequest', 1, token, file, size);
35 |             } else {
36 |                 livelook.emit('endDownload', { token: peer.fileToken });
37 |                 delete livelook.downloads[peer.fileToken];
38 |                 // TODO move onto next download maybe?
39 |             }
40 |         },
41 |         // when we receive a file token
42 |         fileToken: (token, start)  => {
43 |             let upload = livelook.uploads[token];
44 | 
45 |             if (!upload) {
46 |                 return;
47 |             }
48 | 
49 |             let filePath = './' + upload.dir + '/' + upload.file.file;
50 |             let fileStream = fs.createReadStream(filePath, { start });
51 |             fileStream = fileStream.pipe(livelook.uploadThrottler.throttle());
52 |             fileStream.on('error', err => {
53 |                 peer.socket.end();
54 |                 livelook.emit('error', err);
55 |             });
56 |             fileStream.on('end', () => peer.socket.end());
57 |             fileStream.pipe(peer.socket);
58 |         },
59 |         fileData: data => {
60 |             livelook.emit('fileData', { token: peer.fileToken, data });
61 |         }
62 |     };
63 | 
64 |     Object.keys(handlers).forEach(h => peer.on(h, handlers[h]));
65 | };
66 | 


--------------------------------------------------------------------------------
/lib/transfer-peer/index.js:
--------------------------------------------------------------------------------
  1 | // peers with cType F
  2 | 
  3 | const EventEmitter = require('events').EventEmitter;
  4 | const net = require('net');
  5 | const toPeer = require('../message/to-peer');
  6 | const Uint64LE = require('int64-buffer').Uint64LE;
  7 | const makeToken = require('../make-token');
  8 | const attachHandlers = require('./handlers');
  9 | 
 10 | class TransferPeer extends EventEmitter {
 11 |     constructor(args) {
 12 |         super();
 13 | 
 14 |         this.username = args.username; // TODO may not need
 15 |         this.ip = args.ip;
 16 |         this.port = args.port;
 17 | 
 18 |         if (typeof args.isUpload === 'undefined') {
 19 |             this.isUpload = true;
 20 |         } else {
 21 |             this.isUpload = !!args.isUpload;
 22 |         }
 23 | 
 24 |         if (!args.token) {
 25 |             this.token = makeToken();
 26 |         } else {
 27 |             this.token = args.token;
 28 |         }
 29 | 
 30 |         this.socket = new net.Socket();
 31 |         this.connected = false;
 32 | 
 33 |         this.socket.on('close', () => {
 34 |             this.connected = false;
 35 |             this.emit('close');
 36 |         });
 37 | 
 38 |         if (this.isUpload) {
 39 |             this.incomingData = Buffer.alloc(0);
 40 |             this.fileToken = null;
 41 |             this.fileStart = null;
 42 | 
 43 |             this.socket.on('data', data => {
 44 |                 // this shouldn't happen
 45 |                 if (this.fileToken && this.fileStart) {
 46 |                     return;
 47 |                 }
 48 | 
 49 |                 this.incomingData = Buffer.concat([this.incomingData, data]);
 50 | 
 51 |                 if (!this.fileToken && this.incomingData.length >= 4) {
 52 |                     this.fileToken = this.incomingData.readUInt32LE(0);
 53 |                     this.incomingData = this.incomingData.slice(4);
 54 |                 }
 55 | 
 56 |                 if (!this.fileStart && this.incomingData.length >= 8) {
 57 |                     this.fileStart = new Uint64LE(this.incomingData, 0).toNumber();
 58 |                     this.incomingData = this.incomingData.slice(8);
 59 |                     this.emit('fileToken', this.fileToken, this.fileStart);
 60 |                 }
 61 |             });
 62 |         } else {
 63 |             this.bytesDownloaded = 0;
 64 | 
 65 |             this.socket.on('data', data => {
 66 |                 this.bytesDownloaded += data.length;
 67 | 
 68 |                 if (this.bytesDownloaded >= this.fileSize) {
 69 |                     this.socket.end();
 70 |                 } else {
 71 |                     this.emit('fileData', data);
 72 |                 }
 73 |             });
 74 |         }
 75 | 
 76 |         this.socket.on('error', err => this.emit('error', err));
 77 |     }
 78 | 
 79 |     attachHandlers(livelook) {
 80 |         attachHandlers(livelook, this);
 81 |     }
 82 | 
 83 |     pierceFirewall() {
 84 |         this.socket.write(toPeer.pierceFirewall(this.token).getBuff());
 85 |     }
 86 | 
 87 |     peerInit(username) {
 88 |         this.socket.write(toPeer.peerInit(username, 'F', this.token).getBuff());
 89 |     }
 90 | 
 91 |     sendFileToken() {
 92 |         let buff = Buffer.alloc(4);
 93 |         buff.writeInt32LE(this.fileToken);
 94 |         this.socket.write(buff);
 95 |     }
 96 | 
 97 |     sendFileStart() {
 98 |         this.socket.write(new Uint64LE(this.fileStart).toBuffer());
 99 |     }
100 | 
101 |     init(done) {
102 |         this.socket.connect({
103 |             host: this.ip,
104 |             port: this.port
105 |         }, () => {
106 |             this.connected = true;
107 |             this.emit('connect');
108 | 
109 |             if (done) {
110 |                 done();
111 |             }
112 |         });
113 |     }
114 | }
115 | 
116 | module.exports = TransferPeer;
117 | 


--------------------------------------------------------------------------------
/lib/upload-speed.js:
--------------------------------------------------------------------------------
 1 | const speedTest = require('speedtest-net');
 2 | 
 3 | module.exports = done => {
 4 |     /*let test = speedTest({ maxTime: 5000 });
 5 |     let finished = false;
 6 | 
 7 |     test.on('data', data => {
 8 |         if (!finished) {
 9 |             finished = true;
10 |             done(null, data.speeds.upload * 1024 * 1024);
11 |         }
12 |     });
13 | 
14 |     test.on('error', err => {
15 |         if (!finished) {
16 |             finished = true;
17 |             done(err);
18 |         }
19 |     });*/
20 | 
21 |     done(null, 614400);
22 | };
23 | 


--------------------------------------------------------------------------------
/livelook.svg:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="UTF-8" standalone="no"?>
  2 | <svg
  3 |    xmlns:dc="http://purl.org/dc/elements/1.1/"
  4 |    xmlns:cc="http://creativecommons.org/ns#"
  5 |    xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
  6 |    xmlns:svg="http://www.w3.org/2000/svg"
  7 |    xmlns="http://www.w3.org/2000/svg"
  8 |    xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
  9 |    xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
 10 |    id="Layer_1"
 11 |    enable-background="new 0 0 100 100"
 12 |    xml:space="preserve"
 13 |    viewBox="0 0 91.667065 125.50621"
 14 |    version="1.1"
 15 |    y="0px"
 16 |    x="0px"
 17 |    sodipodi:docname="cute-note-brows.svg"
 18 |    inkscape:version="0.92.4 (5da689c313, 2019-01-14)"
 19 |    width="110"
 20 |    height="140"><defs
 21 |    id="defs841"><filter
 22 |      style="color-interpolation-filters:sRGB"
 23 |      inkscape:label="Drop Shadow"
 24 |      id="filter4125"><feFlood
 25 |        flood-opacity="0.498039"
 26 |        flood-color="rgb(0,0,0)"
 27 |        result="flood"
 28 |        id="feFlood4115" /><feComposite
 29 |        in="flood"
 30 |        in2="SourceGraphic"
 31 |        operator="in"
 32 |        result="composite1"
 33 |        id="feComposite4117" /><feGaussianBlur
 34 |        in="composite1"
 35 |        stdDeviation="0.5"
 36 |        result="blur"
 37 |        id="feGaussianBlur4119" /><feOffset
 38 |        dx="-1.6"
 39 |        dy="1.6"
 40 |        result="offset"
 41 |        id="feOffset4121" /><feComposite
 42 |        in="SourceGraphic"
 43 |        in2="offset"
 44 |        operator="over"
 45 |        result="composite2"
 46 |        id="feComposite4123" /></filter></defs><sodipodi:namedview
 47 |    pagecolor="#ffffff"
 48 |    bordercolor="#666666"
 49 |    borderopacity="1"
 50 |    objecttolerance="10"
 51 |    gridtolerance="10"
 52 |    guidetolerance="10"
 53 |    inkscape:pageopacity="0"
 54 |    inkscape:pageshadow="2"
 55 |    inkscape:window-width="1920"
 56 |    inkscape:window-height="1080"
 57 |    id="namedview839"
 58 |    showgrid="false"
 59 |    inkscape:zoom="2.2325"
 60 |    inkscape:cx="170.67354"
 61 |    inkscape:cy="102.59564"
 62 |    inkscape:window-x="1920"
 63 |    inkscape:window-y="0"
 64 |    inkscape:window-maximized="0"
 65 |    inkscape:current-layer="Layer_1"
 66 |    fit-margin-top="0"
 67 |    fit-margin-left="0"
 68 |    fit-margin-right="0"
 69 |    fit-margin-bottom="0" />
 70 | <path
 71 |    style="fill:#000000;filter:url(#filter4125)"
 72 |    d="M 73.439811,11.658116 A 11.194427,16.956266 0 0 0 63.172229,21.880773 c -2.635898,0.417338 -5.190509,0.872883 -7.597656,1.375 A 11.194427,16.956266 0 0 0 46.021838,15.107335 11.194427,16.956266 0 0 0 35.019885,28.997961 c -3.846555,1.374609 -6.068359,2.361328 -6.068359,2.361328 l -0.02148,62.708984 c -3.411,-1.354 -7.558484,-1.67439 -11.771484,-0.65039 -9.0829995,2.207 -15.0311555,9.820817 -13.2851555,17.007817 1.746,7.187 10.5234685,11.22358 19.6054685,9.01758 8.564,-2.081 14.338812,-8.96848 13.507812,-15.77148 V 56.81632 c 0,0 19.403266,-6.783375 44.572264,-8.484375 v 34.849609 c -3.374,-1.292 -7.44212,-1.585078 -11.57812,-0.580078 -9.083003,2.206 -15.031159,9.81786 -13.28516,17.005864 1.745001,7.187 10.52247,11.22554 19.60547,9.01953 7.931,-1.927 13.47189,-7.97863 13.58789,-14.265628 l 0.002,0.0059 v -74.25 c -2.29701,-0.07638 -4.5618,-0.08297 -6.79493,-0.04101 a 11.194427,16.956266 0 0 0 -9.65624,-8.41797 z"
 73 |    id="path834-8"
 74 |    inkscape:connector-curvature="0" /><path
 75 |    d="m 89.891687,20.11632 c -33.501,-1.114 -60.941,11.243 -60.941,11.243 l -0.02,62.709004 c -3.411,-1.354 -7.559,-1.675 -11.772,-0.651 -9.0829994,2.207 -15.0309994,9.820006 -13.2849994,17.007006 1.746,7.187 10.5239994,11.225 19.6059994,9.019 8.564,-2.081 14.338,-8.969 13.507,-15.772 V 56.81632 c 0,0 19.404,-6.784 44.573,-8.485 v 34.849004 c -3.374,-1.292 -7.443,-1.585 -11.579,-0.58 -9.083,2.206 -15.031,9.819 -13.285,17.007 1.745,7.187006 10.523,11.224006 19.606,9.018006 7.931,-1.927 13.471,-7.97701 13.587,-14.264006 l 0.003,0.004 z"
 76 |    id="path834"
 77 |    style="fill:#ffcc00"
 78 |    inkscape:connector-curvature="0" />
 79 | <metadata
 80 |    id="metadata836"><rdf:RDF><cc:Work><dc:format>image/svg+xml</dc:format><dc:type
 81 |          rdf:resource="http://purl.org/dc/dcmitype/StillImage" /><cc:license
 82 |          rdf:resource="http://creativecommons.org/publicdomain/zero/1.0/" /><dc:publisher><cc:Agent
 83 |            rdf:about="http://openclipart.org/"><dc:title>Openclipart</dc:title></cc:Agent></dc:publisher><dc:title></dc:title></cc:Work><cc:License
 84 |        rdf:about="http://creativecommons.org/publicdomain/zero/1.0/"><cc:permits
 85 |          rdf:resource="http://creativecommons.org/ns#Reproduction" /><cc:permits
 86 |          rdf:resource="http://creativecommons.org/ns#Distribution" /><cc:permits
 87 |          rdf:resource="http://creativecommons.org/ns#DerivativeWorks" /></cc:License></rdf:RDF></metadata><ellipse
 88 |    ry="16.956266"
 89 |    rx="11.194427"
 90 |    cy="32.062328"
 91 |    cx="46.020954"
 92 |    id="path4236"
 93 |    style="opacity:1;fill:#ffffff;fill-opacity:1;stroke:#2e3436;stroke-width:1.75956011;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1" /><circle
 94 |    r="4.7740941"
 95 |    cy="38.084179"
 96 |    cx="46.333714"
 97 |    id="path4240"
 98 |    style="opacity:1;fill:#000000;fill-opacity:1;stroke:none;stroke-width:2;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1" /><path
 99 |    d="M 38.051008,11.989476 A 11.194427,16.956266 0 0 1 50.924721,9.9480024"
100 |    sodipodi:open="true"
101 |    sodipodi:end="5.2245345"
102 |    sodipodi:start="3.9916204"
103 |    sodipodi:ry="16.956266"
104 |    sodipodi:rx="11.194427"
105 |    sodipodi:cy="24.728697"
106 |    sodipodi:cx="45.438908"
107 |    sodipodi:type="arc"
108 |    style="opacity:1;fill:none;fill-opacity:1;stroke:#2e3436;stroke-width:1.75956011;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1"
109 |    id="ellipse4244" /><ellipse
110 |    ry="16.956266"
111 |    rx="11.194427"
112 |    cy="28.614058"
113 |    cx="73.439384"
114 |    id="path4236-8"
115 |    style="opacity:1;fill:#ffffff;fill-opacity:1;stroke:#2e3436;stroke-width:1.75956011;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1" /><circle
116 |    cy="34.635906"
117 |    cx="73.752144"
118 |    id="path4240-5"
119 |    style="opacity:1;fill:#000000;fill-opacity:1;stroke:none;stroke-width:2;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1"
120 |    r="4.7740941" /><path
121 |    d="M 65.469438,8.5412029 A 11.194427,16.956266 0 0 1 78.343151,6.4997297"
122 |    sodipodi:open="true"
123 |    sodipodi:end="5.2245345"
124 |    sodipodi:start="3.9916204"
125 |    sodipodi:ry="16.956266"
126 |    sodipodi:rx="11.194427"
127 |    sodipodi:cy="21.280424"
128 |    sodipodi:cx="72.857338"
129 |    sodipodi:type="arc"
130 |    style="opacity:1;fill:none;fill-opacity:1;stroke:#2e3436;stroke-width:1.75956011;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1"
131 |    id="ellipse4244-0" /></svg>


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "livelook",
 3 |   "version": "0.0.0",
 4 |   "description": "soulseek client in javascript",
 5 |   "main": "index.js",
 6 |   "scripts": {
 7 |     "test": "node test"
 8 |   },
 9 |   "repository": {
10 |     "type": "git",
11 |     "url": "git+https://github.com/misterhat/livelook.git"
12 |   },
13 |   "keywords": [
14 |     "soulseek",
15 |     "slsk",
16 |     "p2p",
17 |     "mp3",
18 |     "client"
19 |   ],
20 |   "author": "Zorian Medwid <misterhat144@gmail.com>",
21 |   "license": "AGPL-3.0+",
22 |   "bugs": {
23 |     "url": "https://github.com/misterhat/livelook/issues"
24 |   },
25 |   "homepage": "https://github.com/misterhat/livelook#readme",
26 |   "devDependencies": {
27 |     "tap": "^13.0.4"
28 |   },
29 |   "dependencies": {
30 |     "async": "^2.6.2",
31 |     "chokidar": "^3.0.0",
32 |     "get-port": "^5.0.0",
33 |     "int64-buffer": "^0.99.1007",
34 |     "lazystream": "^1.0.0",
35 |     "music-metadata": "^3.6.1",
36 |     "nat-pmp": "^1.0.0",
37 |     "network": "^0.4.1",
38 |     "recursive-readdir": "^2.2.2",
39 |     "speedtest-net": "^1.5.1",
40 |     "stream-throttle": "^0.1.3",
41 |     "tmp": "^0.1.0"
42 |   }
43 | }
44 | 


--------------------------------------------------------------------------------
/test.js:
--------------------------------------------------------------------------------
 1 | const LiveLook = require('./');
 2 | 
 3 | let livelook = new LiveLook({
 4 |     username: 'toadtripler',
 5 |     password: 'DEFINITELY TRIPLES TOADS',
 6 |     sharedFolder: './mp3s',
 7 |     description: 'not responsible for toad-related mutations',
 8 |     autojoin: [ 'nicotine' ]
 9 | });
10 | 
11 | livelook.on('error', err => console.error(err));
12 | 
13 | livelook.login((err, res) => {
14 |     if (err) {
15 |         return console.error(err);
16 |     } else if (!res.success) {
17 |         return console.log('invalid password lol');
18 |     }
19 | 
20 |     livelook.on('sayChatroom', msg => {
21 |         if (msg.room) {
22 |             console.log(`[${msg.room}] <${msg.username}> ${msg.message}`);
23 |         } else {
24 |             console.log(`<${msg.username}> ${msg.message}`);
25 |         }
26 |     });
27 | 
28 |     livelook.on('messageUser', msg => {
29 |         console.log(`<${msg.username}> ${msg.message}`);
30 |         livelook.messageUser(msg.username, 'hey fug you guy xD');
31 |     });
32 | 
33 |     setTimeout(() => {
34 |         //livelook.getPeerAddress('frogdoubler', console.log);
35 |         livelook.connectToPeerUsername('fourfish', (err, peer) => {
36 |             console.log(err, peer);
37 |         });
38 |     }, 1000);
39 | });
40 | 


--------------------------------------------------------------------------------