renamed onionr dir and bugfixes/linting progress

src/httpapi/miscclientapi/__init__.py

@@ -0,0 +1 @@
+from . import getblocks, staticfiles, endpoints, motd

src/httpapi/miscclientapi/endpoints.py

@@ -0,0 +1,138 @@
+'''
+    Onionr - Private P2P Communication
+
+    Misc client API endpoints too small to need their own file and that need access to the client api inst
+'''
+'''
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+'''
+import os
+import subprocess
+
+from flask import Response, Blueprint, request, send_from_directory, abort
+import unpaddedbase32
+
+from httpapi import apiutils
+import onionrcrypto, config
+from netcontroller import NetController
+from serializeddata import SerializedData
+from onionrutils import mnemonickeys
+from onionrutils import bytesconverter
+from etc import onionrvalues
+from utils import reconstructhash
+from onionrcommands import restartonionr
+
+pub_key = onionrcrypto.pub_key.replace('=', '')
+
+SCRIPT_NAME = os.path.dirname(os.path.realpath(__file__)) + f'/../../../{onionrvalues.SCRIPT_NAME}'
+
+class PrivateEndpoints:
+    def __init__(self, client_api):
+        private_endpoints_bp = Blueprint('privateendpoints', __name__)
+        self.private_endpoints_bp = private_endpoints_bp
+
+        @private_endpoints_bp.route('/www/<path:path>', endpoint='www')
+        def wwwPublic(path):
+            if not config.get("www.private.run", True):
+                abort(403)
+            return send_from_directory(config.get('www.private.path', 'static-data/www/private/'), path)
+
+        @private_endpoints_bp.route('/hitcount')
+        def get_hit_count():
+            return Response(str(client_api.publicAPI.hitCount))
+
+        @private_endpoints_bp.route('/queueResponseAdd/<name>', methods=['post'])
+        def queueResponseAdd(name):
+            # Responses from the daemon. TODO: change to direct var access instead of http endpoint
+            client_api.queueResponse[name] = request.form['data']
+            return Response('success')
+        
+        @private_endpoints_bp.route('/queueResponse/<name>')
+        def queueResponse(name):
+            # Fetch a daemon queue response
+            resp = 'failure'
+            try:
+                resp = client_api.queueResponse[name]
+            except KeyError:
+                pass
+            else:
+                del client_api.queueResponse[name]
+            if resp == 'failure':
+                return resp, 404
+            else:
+                return resp
+            
+        @private_endpoints_bp.route('/ping')
+        def ping():
+            # Used to check if client api is working
+            return Response("pong!")
+
+        @private_endpoints_bp.route('/lastconnect')
+        def lastConnect():
+            return Response(str(client_api.publicAPI.lastRequest))
+
+        @private_endpoints_bp.route('/waitforshare/<name>', methods=['post'])
+        def waitforshare(name):
+            '''Used to prevent the **public** api from sharing blocks we just created'''
+            if not name.isalnum(): raise ValueError('block hash needs to be alpha numeric')
+            name = reconstructhash.reconstruct_hash(name)
+            if name in client_api.publicAPI.hideBlocks:
+                client_api.publicAPI.hideBlocks.remove(name)
+                return Response("removed")
+            else:
+                client_api.publicAPI.hideBlocks.append(name)
+                return Response("added")
+
+        @private_endpoints_bp.route('/shutdown')
+        def shutdown():
+            return apiutils.shutdown.shutdown(client_api)
+
+        @private_endpoints_bp.route('/restartclean')
+        def restart_clean():
+            subprocess.Popen([SCRIPT_NAME, 'restart'])
+            return Response("bye")
+        
+        @private_endpoints_bp.route('/getstats')
+        def getStats():
+            # returns node stats
+            while True:
+                try:    
+                    return Response(client_api._too_many.get(SerializedData).get_stats())
+                except AttributeError as e:
+                    pass
+        
+        @private_endpoints_bp.route('/getuptime')
+        def showUptime():
+            return Response(str(client_api.getUptime()))
+        
+        @private_endpoints_bp.route('/getActivePubkey')
+        def getActivePubkey():
+            return Response(pub_key)
+
+        @private_endpoints_bp.route('/getHumanReadable')
+        def getHumanReadableDefault():
+            return Response(mnemonickeys.get_human_readable_ID())
+
+        @private_endpoints_bp.route('/getHumanReadable/<name>')
+        def getHumanReadable(name):
+            name = unpaddedbase32.repad(bytesconverter.str_to_bytes(name))
+            return Response(mnemonickeys.get_human_readable_ID(name))
+        
+        @private_endpoints_bp.route('/getBase32FromHumanReadable/<words>')
+        def get_base32_from_human_readable(words):
+            return Response(bytesconverter.bytes_to_str(mnemonickeys.get_base32(words)))
+
+        @private_endpoints_bp.route('/gettorsocks')
+        def get_tor_socks():
+            return Response(str(client_api._too_many.get(NetController).socksPort))

src/httpapi/miscclientapi/getblocks.py

@@ -0,0 +1,65 @@
+'''
+    Onionr - Private P2P Communication
+
+    Create blocks with the client api server
+'''
+'''
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+'''
+from flask import Blueprint, Response, abort
+from onionrblocks import onionrblockapi
+from .. import apiutils
+from onionrutils import stringvalidators
+from coredb import blockmetadb
+
+client_get_block = apiutils.GetBlockData()
+
+client_get_blocks = Blueprint('miscclient', __name__)
+
+@client_get_blocks.route('/getblocksbytype/<name>')
+def get_blocks_by_type_endpoint(name):
+    blocks = blockmetadb.get_blocks_by_type(name)
+    return Response(','.join(blocks))
+
+@client_get_blocks.route('/getblockbody/<name>')
+def getBlockBodyData(name):
+    resp = ''
+    if stringvalidators.validate_hash(name):
+        try:
+            resp = onionrblockapi.Block(name, decrypt=True).bcontent
+        except TypeError:
+            pass
+    else:
+        abort(404)
+    return Response(resp)
+
+@client_get_blocks.route('/getblockdata/<name>')
+def getData(name):
+    resp = ""
+    if stringvalidators.validate_hash(name):
+        if name in blockmetadb.get_block_list():
+            try:
+                resp = client_get_block.get_block_data(name, decrypt=True)
+            except ValueError:
+                pass
+        else:
+            abort(404)
+    else:
+        abort(404)
+    return Response(resp)
+
+@client_get_blocks.route('/getblockheader/<name>')
+def getBlockHeader(name):
+    resp = client_get_block.get_block_data(name, decrypt=True, headerOnly=True)
+    return Response(resp)

src/httpapi/miscclientapi/motd/__init__.py

@@ -0,0 +1,27 @@
+from flask import Blueprint
+from flask import Response
+import unpaddedbase32
+
+from coredb import blockmetadb
+import onionrblocks
+from etc import onionrvalues
+import config
+from onionrutils import bytesconverter
+
+bp = Blueprint('motd', __name__)
+
+signer = config.get("motd.motd_key", onionrvalues.MOTD_SIGN_KEY)
+
+@bp.route('/getmotd')
+def get_motd()->Response:
+    motds = blockmetadb.get_blocks_by_type("motd")
+    newest_time = 0
+    message = "No MOTD currently present."
+    for x in motds:
+        bl = onionrblocks.onionrblockapi.Block(x)
+        if not bl.verifySig() or bl.signer != bytesconverter.bytes_to_str(unpaddedbase32.repad(bytesconverter.str_to_bytes(signer))): continue
+        if not bl.isSigner(signer): continue
+        if bl.claimedTime > newest_time:
+            newest_time = bl.claimedTime
+            message = bl.bcontent
+    return Response(message, headers={"Content-Type": "text/plain"})

src/httpapi/miscclientapi/staticfiles.py

@@ -0,0 +1,92 @@
+'''
+    Onionr - Private P2P Communication
+
+    Register static file routes
+'''
+'''
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+'''
+import os
+import mimetypes
+from flask import Blueprint, send_from_directory
+
+# Was having some mime type issues on windows, this appeared to fix it.
+# we have no-sniff set, so if the mime types are invalid sripts can't load.
+mimetypes.add_type('application/javascript', '.js')
+mimetypes.add_type('text/css', '.css')
+
+static_files_bp = Blueprint('staticfiles', __name__)
+
+root = os.path.dirname(os.path.realpath(__file__)) + '/../../../static-data/www/' # should be set to onionr install directory from onionr startup
+
+@static_files_bp.route('/onboarding/', endpoint='onboardingIndex')
+def onboard():
+    return send_from_directory(f'{root}onboarding/', "index.html")
+
+@static_files_bp.route('/onboarding/<path:path>', endpoint='onboarding')
+def onboard_files(path):
+    return send_from_directory(f'{root}onboarding/', path)
+
+@static_files_bp.route('/chat/', endpoint='chatIndex')
+def chat_index():
+    return send_from_directory(root + 'chat/', "index.html")
+
+@static_files_bp.route('/chat/<path:path>', endpoint='chat')
+def load_chat(path):
+    return send_from_directory(root + 'chat/', path)
+
+@static_files_bp.route('/board/', endpoint='board')
+def loadBoard():
+    return send_from_directory(root + 'board/', "index.html")
+
+@static_files_bp.route('/mail/<path:path>', endpoint='mail')
+def loadMail(path):
+    return send_from_directory(root + 'mail/', path)
+
+@static_files_bp.route('/mail/', endpoint='mailindex')
+def loadMailIndex():
+    return send_from_directory(root + 'mail/', 'index.html')
+
+@static_files_bp.route('/friends/<path:path>', endpoint='friends')
+def loadContacts(path):
+    return send_from_directory(root + 'friends/', path)
+
+@static_files_bp.route('/friends/', endpoint='friendsindex')
+def loadContacts():
+    return send_from_directory(root + 'friends/', 'index.html')
+
+@static_files_bp.route('/profiles/<path:path>', endpoint='profiles')
+def loadContacts(path):
+    return send_from_directory(root + 'profiles/', path)
+
+@static_files_bp.route('/profiles/', endpoint='profilesindex')
+def loadContacts():
+    return send_from_directory(root + 'profiles/', 'index.html')
+
+@static_files_bp.route('/board/<path:path>', endpoint='boardContent')
+def boardContent(path):
+    return send_from_directory(root + 'board/', path)
+
+@static_files_bp.route('/shared/<path:path>', endpoint='sharedContent')
+def sharedContent(path):
+    return send_from_directory(root + 'shared/', path)
+
+@static_files_bp.route('/', endpoint='onionrhome')
+def hello():
+    # ui home
+    return send_from_directory(root + 'private/', 'index.html')
+
+@static_files_bp.route('/private/<path:path>', endpoint='homedata')
+def homedata(path):
+    return send_from_directory(root + 'private/', path)