%PDF-
%PDF-
Mini Shell
Mini Shell
# -*- Mode: python; coding: utf-8; tab-width: 8; indent-tabs-mode: t; -*-
#
# Copyright (C) 2016 Jonathan Matthew
#
# 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 2, or (at your option)
# any later version.
#
# The Rhythmbox authors hereby grant permission for non-GPL compatible
# GStreamer plugins to be used and distributed together with GStreamer
# and Rhythmbox. This permission is above and beyond the permissions granted
# by the GPL license by which Rhythmbox is covered. If you modify this code
# you may extend this exception to your version of the code, but you are not
# obligated to do so. If you do not wish to do so, delete this exception
# statement from your 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, write to the Free Software
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
import gi
gi.require_version('Soup', '3.0')
from gi.repository import GLib, GObject, Gio, Peas, PeasGtk, Soup, Gtk
from gi.repository import RB
import rb
import sys
import os.path
import json
import re
import time
import struct
import siphash
import gettext
gettext.install('rhythmbox', RB.locale_dir())
def get_host_name():
try:
p = Gio.DBusProxy.new_for_bus_sync(Gio.BusType.SYSTEM,
0,
None,
'org.freedesktop.Avahi',
'/',
'org.freedesktop.Avahi.Server')
return p.GetHostNameFqdn()
except Exception as e:
# ignore
import socket
return socket.gethostname()
class ClientSession(object):
def __init__(self, plugin, connection, connid):
print("new connection attached")
self.connid = connid
self.conn = connection
self.conn.connect("message", self.message_cb)
self.conn.connect("closed", self.closed_cb)
self.plugin = plugin
self.actions = {
'status': self.plugin.client_status,
'next': self.plugin.client_next,
'previous': self.plugin.client_previous,
'playpause': self.plugin.client_playpause,
'seek': self.plugin.client_seek
}
def message_cb(self, conn, msgtype, message):
if msgtype != Soup.WebsocketDataType.TEXT:
print("binary message received?")
return
d = message.get_data().decode("utf-8")
print("message received: %s" % d)
try:
m = json.loads(d)
action = m.get('action')
print("doing %s" % action)
if action in self.actions:
r = self.actions[action](m)
else:
r = {'result': 'what'}
print("responding %s" % str(r))
self.conn.send_text(json.dumps(r))
except Exception as e:
sys.excepthook(*sys.exc_info())
def closed_cb(self, conn):
self.plugin.player_websocket_closed(self, self.connid)
def dispatch(self, message):
self.conn.send_text(message)
def disconnect(self):
self.conn.close(0, "")
class TrackStreamer(object):
def __init__(self, server, message, track, content_type):
self.server = server
self.message = message
self.message.connect("wrote-chunk", self.wrote_chunk)
self.trackfile = Gio.File.new_for_uri(track)
self.content_type = content_type
self.stream = None
self.offset = 0
self.done = False
print("streaming " + track)
def wrote_chunk(self, msg):
if not self.done:
self.server.pause_message(self.message)
def open(self):
print("opening")
self.trackfile.read_async(GLib.PRIORITY_DEFAULT, None, self.opened)
self.server.pause_message(self.message)
def opened(self, obj, result):
try:
print("track opened")
headers = self.message.props.response_headers
headers.set_content_type(self.content_type)
headers.set_encoding(Soup.Encoding.CHUNKED)
body = self.message.props.response_body
body.set_accumulate(False)
self.stream = self.trackfile.read_finish(result)
self.message.set_status(200)
self.read_more()
except Exception as e:
sys.excepthook(*sys.exc_info())
self.message.set_status(500)
self.server.unpause_message(self.message)
def read_more(self):
self.stream.read_bytes_async(65536, GLib.PRIORITY_DEFAULT, None, self.read_done)
def read_done(self, obj, result):
body = self.message.props.response_body
try:
b = self.stream.read_bytes_finish(result)
if b.get_size() == 0:
self.done = True
body.complete()
else:
self.offset = self.offset + b.get_size()
body.append(b.get_data()) # uh..
self.read_more()
self.server.unpause_message(self.message)
except Exception as e:
sys.excepthook(*sys.exc_info())
if (self.offset == 0):
self.message.set_status(500)
else:
body.complete()
self.server.unpause_message(self.message)
class WebRemotePlugin(GObject.Object, Peas.Activatable):
__gtype_name = 'WebRemotePlugin'
object = GObject.property(type=GObject.GObject)
signature_max_age = 60
# we don't really need a huge replay memory.
# clients should only make requests every couple of minutes,
# and signatures are only valid for (currently) up to two minutes.
replay_memory = 20
string_props = {
RB.RhythmDBPropType.TITLE: 'title',
RB.RhythmDBPropType.ARTIST: 'artist',
RB.RhythmDBPropType.ALBUM: 'album',
RB.RhythmDBPropType.ALBUM_ARTIST: 'album-artist',
RB.RhythmDBPropType.GENRE: 'genre',
RB.RhythmDBPropType.COMPOSER: 'composer',
RB.RhythmDBPropType.TITLE: 'title',
}
ulong_props = {
RB.RhythmDBPropType.ENTRY_ID: 'id',
RB.RhythmDBPropType.YEAR: 'year',
#RB.RhythmDBPropType.BEATS_PER_MINUTE: 'bpm',
RB.RhythmDBPropType.BITRATE: 'bitrate',
RB.RhythmDBPropType.DURATION: 'duration',
RB.RhythmDBPropType.TRACK_NUMBER: 'track-number',
RB.RhythmDBPropType.TRACK_TOTAL: 'track-total',
RB.RhythmDBPropType.DISC_NUMBER: 'disc-number',
RB.RhythmDBPropType.DISC_TOTAL: 'disc-total'
}
def __init__(self):
GObject.Object.__init__(self)
self.settings = Gio.Settings.new("org.gnome.rhythmbox.plugins.webremote")
self.settings.connect("changed", self.settings_changed_cb)
self.server = None
self.next_connid = 0
self.connections = {}
self.replay = []
self.access_key = None
self.listen_reset = False
def get_sign_key(self, id):
# some day there will be multiple keys
a = self.settings['access-key']
ea = a.encode()
pa = (a + 4 * '\0').encode()
k = [0, 0, 0, 0]
i = 0
ki = 0
uint = struct.Struct("<I")
while i < len(ea):
k[ki] = (k[ki] + uint.unpack(pa[i:i+4])[0]) % 0xffffffff
i = i + 4
ki = (ki + 1) % 4
return k
def check_http_signature(self, path, query):
try:
qargs = dict([b.split("=") for b in query.split("&")])
ts = qargs['ts']
sig = qargs['sig']
keyid = qargs.get("k", "default") # not used yet
if sig in self.replay:
print("replayed signature " + sig + " in request for " + path)
return False
its = int(ts) / 1000
now = time.time()
max = self.signature_max_age
print("request timestamp: " + ts + ", min: " + str(now - max) + ", max: " + str(now + max))
if (its < (now - max)) or (its > (now + max)):
return False
message = (path + "\n" + ts).encode()
check = siphash.SipHash_2_4(self.get_sign_key(keyid), message).hexdigest()
print("request signature: " + sig + ", expecting: " + check.decode())
if check == sig.encode():
self.replay.insert(0, sig)
self.replay = self.replay[:self.replay_memory]
return True
return False
except Exception as e:
sys.excepthook(*sys.exc_info())
return False
def check_http_msg_signature(self, msg):
u = msg.get_uri()
return self.check_http_signature(u.get_path(), u.get_query())
def player_websocket_cb(self, server, msg, path, conn):
(upath, query) = path.split(":", 1)
if self.check_http_signature(upath, query) is False:
conn.close(403, "whatever")
return
cs = ClientSession(self, conn, self.next_connid)
self.connections[self.next_connid] = cs
self.next_connid = self.next_connid + 1
def player_websocket_closed(self, connection, connid):
self.connections.pop(connid)
def dispatch(self, message):
m = json.dumps(message)
for c in self.connections.values():
c.dispatch(m)
def album_art_filename(self, filename):
if filename is None:
return None
if filename.startswith(self.artcache) is False:
return None
rfn = filename[len(self.artcache):].lstrip('/')
return os.path.normpath(rfn)
def entry_details(self, entry):
m = {}
if entry is not None:
for (p, k) in self.string_props.items():
m[k] = entry.get_string(p)
for (p, k) in self.ulong_props.items():
m[k] = entry.get_ulong(p)
key = entry.create_ext_db_key(RB.RhythmDBPropType.ALBUM)
(filename, lkey) = self.art_store.lookup(key)
m['albumart'] = self.album_art_filename(filename)
return m
def set_playing_position(self, update):
try:
(r, pos) = self.shell_player.get_playing_time()
update['position'] = pos * 1000
except Exception as e:
pass
def client_status(self, message):
entry = self.shell_player.get_playing_entry()
if entry:
m = self.entry_details(entry)
self.set_playing_position(m)
p = self.shell_player.get_playing()
m['playing'] = p[1]
else:
m = { 'playing': False, 'id': 0 }
m['hostname'] = GLib.get_host_name()
return m
def client_next(self, message):
try:
self.shell_player.do_next()
return {'result': 'ok'}
except Exception as e:
return {'result': str(e) }
def client_previous(self, message):
try:
self.shell_player.do_previous()
return {'result': 'ok'}
except Exception as e:
return {'result': str(e) }
def client_playpause(self, message):
try:
self.shell_player.playpause()
return {'result': 'ok'}
except Exception as e:
return {'result': str(e) }
def client_seek(self, message):
try:
self.shell_player.set_playing_time(message['time'])
return {'result': 'ok'}
except Exception as e:
return {'result': str(e) }
def playing_song_changed_cb(self, player, entry):
self.elapsed = 0
self.dispatch(self.entry_details(entry))
def playing_changed_cb(self, player, playing):
u = { 'playing': playing }
self.set_playing_position(u)
self.dispatch(u)
def playing_song_property_changed_cb(self, player, uri, prop, oldvalue, newvalue):
if prop in self.string_props:
self.dispatch({ self.string_props[prop]: newvalue })
if prop in self.ulong_props:
self.dispatch({ self.ulong_props[prop]: newvalue })
def elapsed_nano_changed_cb(self, player, elapsed):
if abs(elapsed - self.elapsed) > 1000000000:
self.dispatch({'position': elapsed/1000000}) # ms
self.elapsed = elapsed
def art_added_cb(self, store, key, filename, data):
entry = self.shell_player.get_playing_entry()
if entry is not None and self.db.entry_matches_ext_db_key(entry, key):
self.dispatch({'albumart': self.album_art_filename(filename)})
def send_file_response(self, msg, filename, content_type):
try:
fp = open(filename, 'rb')
d = fp.read()
if callable(content_type):
content_type = content_type(d)
msg.set_response(content_type, Soup.MemoryUse.COPY, d)
msg.set_status(200)
except Exception as e:
sys.excepthook(*sys.exc_info())
msg.set_status(500)
def image_content_type(self, data):
# superhacky
if data[1:4] == b'PNG':
return "image/png"
elif data[0:5] == b'<?xml':
return "image/svg+xml"
elif data[0:4] == b'<svg':
return "image/svg+xml"
else:
return "image/jpeg"
def http_track_cb(self, server, msg, path, query):
if self.check_http_msg_signature(msg) is False:
msg.set_status(403)
return
entry = self.shell_player.get_playing_entry()
if entry is None:
msg.set_status(404)
return
mt = entry.get_string(RB.RhythmDBPropType.MEDIA_TYPE)
ct = RB.gst_media_type_to_mime_type(mt)
s = TrackStreamer(server, msg, entry.get_playback_uri(), ct)
try:
s.open()
except Exception as e:
sys.excepthook(*sys.exc_info())
msg.set_status(500)
def http_art_cb(self, server, msg, path, query):
if self.check_http_msg_signature(msg) is False:
msg.set_status(403)
return
if msg.get_method() != "GET":
msg.set_status(404)
return
if re.match("/art/[^/][a-zA-Z0-9/]+", path) is None:
msg.set_status(404)
return
artpath = os.path.join(self.artcache, path[len("/art/"):])
if not os.path.exists(artpath):
msg.set_status(404)
return
self.send_file_response(msg, artpath, self.image_content_type)
def http_icon_cb(self, server, msg, path, query):
if msg.get_method() != "GET":
msg.set_status(404)
return
if re.match("/icon/[a-zA-Z0-9.-]+/[0-9]+", path) is None:
msg.set_status(404)
return
bits = path.split("/")
iconname = bits[2]
iconsize = int(bits[3])
icon = Gtk.IconTheme.get_default().lookup_icon(iconname, iconsize, Gtk.IconLookupFlags.FORCE_SVG)
if icon is None:
msg.set_status(404)
return
iconfile = icon.get_filename()
try:
res = Gio.resources_lookup_data(iconfile, 0)
data = res.get_data()
content_type = self.image_content_type(data)
msg.set_response(content_type, Soup.MemoryUse.COPY, data)
msg.set_status(200)
except gi.repository.GLib.GError as ge:
# assume we couldn't find the resource, so try it as a filename
self.send_file_response(msg, icon.get_filename(), self.image_content_type)
except Exception as e:
sys.excepthook(*sys.exc_info())
msg.set_status(500)
def serve_static(self, msg, path, subdir, content_type):
if subdir == '':
ssubdir = '/'
else:
ssubdir = "/" + subdir + "/"
if not path.startswith(ssubdir):
msg.set_status(403)
return
relpath = path[len(ssubdir):]
if msg.get_method() != "GET" or relpath.find("/") != -1:
msg.set_status(403)
return
f = rb.find_plugin_file(self, os.path.join(subdir, relpath))
if f is None:
msg.set_status(403)
return
self.send_file_response(msg, f, content_type)
def http_static_css_cb(self, server, msg, path, query):
self.serve_static(msg, path, "css", "text/css")
def http_static_js_cb(self, server, msg, path, query):
self.serve_static(msg, path, "js", "text/javascript")
def http_root_cb(self, server, msg, path, query):
self.serve_static(msg, '/webremote.html', '', 'text/html')
def settings_changed_cb(self, settings, key):
if key == 'listen-port':
if self.http_server is not None and self.listen_reset is False:
self.http_server.disconnect()
self.http_listen()
elif key == 'access-key':
for c in self.connections.values():
c.disconnect()
def http_listen(self):
print("relistening")
port = self.settings['listen-port']
if port != 0:
try:
self.http_server.listen_all(port, 0)
except Exception as e:
port = 0
if port == 0:
print("trying again")
self.listen_reset = True
self.http_server.listen_all(0, 0)
# remember the port number for convenience
uris = self.http_server.get_uris()
if len(uris) > 0:
self.settings['listen-port'] = uris[0].get_port()
self.listen_reset = False
def do_activate(self):
shell = self.object
self.db = shell.props.db
self.artcache = os.path.join(RB.user_cache_dir(), "album-art", "")
self.art_store = RB.ExtDB(name="album-art")
self.art_store.connect("added", self.art_added_cb)
self.shell_player = shell.props.shell_player
self.shell_player.connect("playing-song-changed", self.playing_song_changed_cb)
self.shell_player.connect("playing-song-property-changed", self.playing_song_property_changed_cb)
self.shell_player.connect("playing-changed", self.playing_changed_cb)
self.shell_player.connect("elapsed-nano-changed", self.elapsed_nano_changed_cb)
self.playing_song_changed_cb(self.shell_player, self.shell_player.get_playing_entry())
self.http_server = Soup.Server()
self.http_server.add_handler(path="/art/", callback=self.http_art_cb)
self.http_server.add_handler(path="/icon/", callback=self.http_icon_cb)
self.http_server.add_handler(path="/entry/current/stream", callback=self.http_track_cb)
self.http_server.add_handler(path="/css/", callback=self.http_static_css_cb)
self.http_server.add_handler(path="/js/", callback=self.http_static_js_cb)
self.http_server.add_websocket_handler("/ws/player", None, None, self.player_websocket_cb)
self.http_server.add_handler(path="/", callback=self.http_root_cb)
self.http_listen()
def do_deactivate(self):
self.dispatch({'shutdown': True })
self.server = None
self.connections = {}
class WebRemoteConfig(GObject.Object, PeasGtk.Configurable):
__gtype_name__ = 'WebRemoteConfig'
object = GObject.property(type=GObject.Object)
def accesskey_focus_out_cb(self, widget, event):
k = widget.get_text()
if k != self.access_key:
print("changing access key to %s" % k)
self.access_key = k
self.settings['access-key'] = k
return False
def update_port(self):
hostname = get_host_name()
port = self.settings['listen-port']
url = 'http://%s:%d/' % (hostname, port)
label = _('Launch web remote control')
self.launch_link.set_markup('<a href="%s">%s</a>' % (url, label))
self.portnumber.set_text("%d" % port)
def settings_changed_cb(self, settings, key):
if key == 'listen-port':
self.update_port()
def do_create_configure_widget(self):
self.settings = Gio.Settings.new("org.gnome.rhythmbox.plugins.webremote")
self.settings.connect("changed", self.settings_changed_cb)
ui_file = rb.find_plugin_file(self, "webremote-config.ui")
self.builder = Gtk.Builder()
self.builder.add_from_file(ui_file)
content = self.builder.get_object("webremote-config")
self.portnumber = self.builder.get_object("portnumber")
self.launch_link = self.builder.get_object("launch-link")
self.update_port()
self.key_entry = self.builder.get_object("accesskey")
self.access_key = self.settings['access-key']
if self.access_key:
self.key_entry.set_text(self.access_key)
self.key_entry.connect("focus-out-event", self.accesskey_focus_out_cb)
return content
GObject.type_register(WebRemoteConfig)
Zerion Mini Shell 1.0