Forked mumble-django project from https://bitbucket.org/Svedrin/mumble-django
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
410 lines
15 KiB
410 lines
15 KiB
# -*- coding: utf-8 -*-
|
|
|
|
"""
|
|
* Copyright (C) 2009, Michael "Svedrin" Ziegler <diese-addy@funzt-halt.net>
|
|
*
|
|
* Mumble-Django 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 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This package 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.
|
|
"""
|
|
|
|
import socket
|
|
from PIL import Image
|
|
from struct import pack, unpack
|
|
from zlib import compress, decompress
|
|
|
|
from django.utils.translation import ugettext_lazy as _
|
|
from django.contrib.auth.models import User
|
|
from django.db import models
|
|
|
|
from django.conf import settings
|
|
|
|
from mmobjects import *
|
|
from mctl import *
|
|
|
|
|
|
class Mumble( models.Model ):
|
|
"""Represents a Murmur server instance.
|
|
|
|
All configurable settings are represented by a field in this model. To change the
|
|
settings, just update the appropriate field and call the save() method.
|
|
|
|
To set up a new server instance, instanciate this Model. The first field you should
|
|
define is the "dbus" field, which tells the connector subsystem how to connect to
|
|
the Murmurd master process. Set this to the appropriate DBus service name or the
|
|
Ice proxy string.
|
|
|
|
When an instance of this model is deleted, the according server instance will be
|
|
deleted as well.
|
|
"""
|
|
|
|
name = models.CharField( _('Server Name'), max_length = 200 );
|
|
dbus = models.CharField( _('DBus or ICE base'), max_length = 200, default = settings.DEFAULT_CONN );
|
|
srvid = models.IntegerField( _('Server ID'), editable = False );
|
|
addr = models.CharField( _('Server Address'), max_length = 200 );
|
|
port = models.IntegerField( _('Server Port'), blank = True, null = True );
|
|
url = models.CharField( _('Website URL'), max_length = 200, blank = True );
|
|
motd = models.TextField( _('Welcome Message'), blank = True );
|
|
passwd = models.CharField( _('Server Password'), max_length = 200, blank = True );
|
|
supw = models.CharField( _('Superuser Password'), max_length = 200, blank = True );
|
|
users = models.IntegerField( _('Max. Users'), blank = True, null = True );
|
|
bwidth = models.IntegerField( _('Bandwidth [Bps]'), blank = True, null = True );
|
|
sslcrt = models.TextField( _('SSL Certificate'), blank = True );
|
|
sslkey = models.TextField( _('SSL Key'), blank = True );
|
|
obfsc = models.BooleanField( _('IP Obfuscation'), default = False );
|
|
player = models.CharField( _('Player name regex'), max_length=200, default=r'[-=\w\[\]\{\}\(\)\@\|\.]+' );
|
|
channel = models.CharField( _('Channel name regex'), max_length=200, default=r'[ \-=\w\#\[\]\{\}\(\)\@\|]+' );
|
|
defchan = models.IntegerField( _('Default channel'), default=0 );
|
|
booted = models.BooleanField( _('Boot Server'), default = True );
|
|
|
|
class Meta:
|
|
unique_together = ( ( 'dbus', 'srvid' ), ( 'addr', 'port' ), );
|
|
verbose_name = _('Server instance');
|
|
verbose_name_plural = _('Server instances');
|
|
|
|
def __init__( self, *args, **kwargs ):
|
|
models.Model.__init__( self, *args, **kwargs );
|
|
self._ctl = None;
|
|
self._channels = None;
|
|
self._rootchan = None;
|
|
|
|
def __unicode__( self ):
|
|
if not self.id:
|
|
return u'Murmur "%s" (NOT YET CREATED)' % self.name;
|
|
return u'Murmur "%s" (%d)' % ( self.name, self.srvid );
|
|
|
|
|
|
users_regged = property( lambda self: self.mumbleuser_set.count(), None );
|
|
users_online = property( lambda self: len(self.ctl.getPlayers(self.srvid)), None );
|
|
channel_cnt = property( lambda self: len(self.ctl.getChannels(self.srvid)), None );
|
|
is_public = property( lambda self: self.passwd == '', None );
|
|
|
|
is_server = True;
|
|
is_channel = False;
|
|
is_player = False;
|
|
|
|
|
|
# Ctl instantiation
|
|
def getCtl( self ):
|
|
"""Instantiate and return a MumbleCtl object for this server.
|
|
|
|
Only one instance will be created, and reused on subsequent calls.
|
|
"""
|
|
if not self._ctl:
|
|
self._ctl = MumbleCtlBase.newInstance( self.dbus );
|
|
return self._ctl;
|
|
|
|
ctl = property( getCtl, None );
|
|
|
|
|
|
def save( self, dontConfigureMurmur=False ):
|
|
"""
|
|
Save the options configured in this model instance not only to Django's database,
|
|
but to Murmur as well.
|
|
"""
|
|
if dontConfigureMurmur:
|
|
# skip murmur configuration, e.g. because we're inserting models for existing servers.
|
|
return models.Model.save( self );
|
|
|
|
# check if this server already exists, if not call newServer and set my srvid first
|
|
|
|
if self.id is None:
|
|
self.srvid = self.ctl.newServer();
|
|
|
|
self.ctl.setConf( self.srvid, 'host', socket.gethostbyname( self.addr ) );
|
|
self.ctl.setConf( self.srvid, 'registername', self.name );
|
|
self.ctl.setConf( self.srvid, 'registerurl', self.url );
|
|
self.ctl.setConf( self.srvid, 'welcometext', self.motd );
|
|
self.ctl.setConf( self.srvid, 'password', self.passwd );
|
|
self.ctl.setConf( self.srvid, 'certificate', self.sslcrt );
|
|
self.ctl.setConf( self.srvid, 'key', self.sslkey );
|
|
self.ctl.setConf( self.srvid, 'obfuscate', str(self.obfsc).lower() );
|
|
self.ctl.setConf( self.srvid, 'playername', self.player );
|
|
self.ctl.setConf( self.srvid, 'channelname', self.channel );
|
|
self.ctl.setConf( self.srvid, 'defaultchannel', str(self.defchan) );
|
|
|
|
|
|
if self.port is not None:
|
|
self.ctl.setConf( self.srvid, 'port', str(self.port) );
|
|
else:
|
|
self.ctl.setConf( self.srvid, 'port', '' );
|
|
|
|
if self.users is not None:
|
|
self.ctl.setConf( self.srvid, 'users', str(self.users) );
|
|
else:
|
|
self.ctl.setConf( self.srvid, 'users', '' );
|
|
|
|
if self.bwidth is not None:
|
|
self.ctl.setConf( self.srvid, 'bandwidth', str(self.bwidth) );
|
|
else:
|
|
self.ctl.setConf( self.srvid, 'bandwidth', '' );
|
|
|
|
# registerHostname needs to take the port no into account
|
|
if self.port and self.port != settings.MUMBLE_DEFAULT_PORT:
|
|
self.ctl.setConf( self.srvid, 'registerhostname', "%s:%d" % ( self.addr, self.port ) );
|
|
else:
|
|
self.ctl.setConf( self.srvid, 'registerhostname', self.addr );
|
|
|
|
if self.supw:
|
|
self.ctl.setSuperUserPassword( self.srvid, self.supw );
|
|
self.supw = '';
|
|
|
|
if self.booted != self.ctl.isBooted( self.srvid ):
|
|
if self.booted:
|
|
self.ctl.start( self.srvid );
|
|
else:
|
|
self.ctl.stop( self.srvid );
|
|
|
|
# Now allow django to save the record set
|
|
return models.Model.save( self );
|
|
|
|
|
|
def isUserAdmin( self, user ):
|
|
"""Determine if the given user is an admin on this server."""
|
|
if user.is_authenticated():
|
|
try:
|
|
return self.mumbleuser_set.get( owner=user ).getAdmin();
|
|
except MumbleUser.DoesNotExist:
|
|
return False;
|
|
return False;
|
|
|
|
|
|
# Deletion handler
|
|
def deleteServer( self ):
|
|
"""Delete this server instance from Murmur."""
|
|
self.ctl.deleteServer(self.srvid)
|
|
|
|
@staticmethod
|
|
def pre_delete_listener( **kwargs ):
|
|
kwargs['instance'].deleteServer();
|
|
|
|
|
|
# Channel list
|
|
def getChannels( self ):
|
|
"""Query the channels from Murmur and create a tree structure.
|
|
|
|
Again, this will only be done for the first call to this function. Subsequent
|
|
calls will simply return the list created last time.
|
|
"""
|
|
if self._channels is None:
|
|
self._channels = {};
|
|
chanlist = self.ctl.getChannels(self.srvid);
|
|
links = {};
|
|
|
|
# sometimes, ICE seems to return the Channel list in a weird order.
|
|
# itercount prevents infinite loops.
|
|
itercount = 0;
|
|
maxiter = len(chanlist) * 3;
|
|
while len(chanlist) and itercount < maxiter:
|
|
itercount += 1;
|
|
for theChan in chanlist:
|
|
# Channels - Fields: 0 = ID, 1 = Name, 2 = Parent-ID, 3 = Links
|
|
if( theChan[2] == -1 ):
|
|
# No parent
|
|
self._channels[theChan[0]] = mmChannel( self, theChan );
|
|
elif theChan[2] in self.channels:
|
|
# parent already known
|
|
self._channels[theChan[0]] = mmChannel( self, theChan, self.channels[theChan[2]] );
|
|
else:
|
|
continue;
|
|
|
|
chanlist.remove( theChan );
|
|
|
|
self._channels[theChan[0]].serverId = self.id;
|
|
|
|
# process links - if the linked channels are known, link; else save their ids to link later
|
|
for linked in theChan[3]:
|
|
if linked in self._channels:
|
|
self._channels[theChan[0]].linked.append( self._channels[linked] );
|
|
else:
|
|
if linked not in links:
|
|
links[linked] = list();
|
|
links[linked].append( self._channels[theChan[0]] );
|
|
|
|
# check if earlier round trips saved channel ids to be linked to the current channel
|
|
if theChan[0] in links:
|
|
for targetChan in links[theChan[0]]:
|
|
targetChan.linked.append( self._channels[theChan[0]] );
|
|
|
|
self._channels[0].name = self.name;
|
|
|
|
self.players = {};
|
|
for thePlayer in self.ctl.getPlayers(self.srvid):
|
|
# Players - Fields: 0 = UserID, 6 = ChannelID
|
|
self.players[ thePlayer[0] ] = mmPlayer( self, thePlayer, self._channels[ thePlayer[6] ] );
|
|
|
|
self._channels[0].sort();
|
|
|
|
return self._channels;
|
|
|
|
channels = property( getChannels, None ); """A convenience wrapper for getChannels()."""
|
|
rootchan = property( lambda self: self.channels[0], None ); """A convenience wrapper for getChannels()[0]."""
|
|
|
|
def getURL( self, forUser = None ):
|
|
"""Create an URL of the form mumble://username@host:port/ for this server."""
|
|
userstr = "";
|
|
if forUser is not None:
|
|
userstr = "%s@" % forUser.name;
|
|
|
|
if self.port != settings.MUMBLE_DEFAULT_PORT:
|
|
return "mumble://%s%s:%d/" % ( userstr, self.addr, self.port );
|
|
|
|
return "mumble://%s%s/" % ( userstr, self.addr );
|
|
|
|
connecturl = property( getURL, None ); """A convenience wrapper for getURL()."""
|
|
|
|
version = property( lambda self: self.ctl.getVersion(), None ); """Get the version of Murmur."""
|
|
|
|
|
|
|
|
class MumbleUser( models.Model ):
|
|
"""Represents a User account in Murmur.
|
|
|
|
To change an account, simply set the according field in this model and call the save()
|
|
method to update the account in Murmur and in Django's database. Note that, once saved
|
|
for the first time, the server field must not be changed. Attempting to do this will
|
|
result in an AttributeError. To move an account to a new server, recreate it on the
|
|
new server and delete the old model.
|
|
|
|
When you delete an instance of this model, the according user account will be deleted
|
|
in Murmur as well, after revoking the user's admin privileges.
|
|
"""
|
|
|
|
mumbleid = models.IntegerField( _('Mumble player_id'), editable = False, default = -1 );
|
|
name = models.CharField( _('User name and Login'), max_length = 200 );
|
|
password = models.CharField( _('Login password'), max_length = 200, blank=True );
|
|
server = models.ForeignKey( Mumble, verbose_name=_('Server instance') );
|
|
owner = models.ForeignKey( User, verbose_name=_('Account owner'), null=True, blank=True );
|
|
isAdmin = models.BooleanField( _('Admin on root channel'), default = False );
|
|
|
|
class Meta:
|
|
unique_together = ( ( 'server', 'owner' ), );
|
|
verbose_name = _( 'User account' );
|
|
verbose_name_plural = _( 'User accounts' );
|
|
|
|
is_server = False;
|
|
is_channel = False;
|
|
is_player = True;
|
|
|
|
def __unicode__( self ):
|
|
return _("Mumble user %(mu)s on %(srv)s owned by Django user %(du)s") % { 'mu': self.name, 'srv': self.server, 'du': self.owner };
|
|
|
|
def save( self, dontConfigureMurmur=False ):
|
|
"""Save the settings in this model to Murmur."""
|
|
if dontConfigureMurmur:
|
|
# skip murmur configuration, e.g. because we're inserting models for existing players.
|
|
return models.Model.save( self );
|
|
|
|
# Before the record set is saved, update Murmur via controller.
|
|
ctl = self.server.ctl;
|
|
|
|
if self.owner:
|
|
email = self.owner.email;
|
|
else:
|
|
email = settings.DEFAULT_FROM_EMAIL;
|
|
|
|
if self.id is None:
|
|
# This is a new user record, so Murmur doesn't know about it yet
|
|
if len( ctl.getRegisteredPlayers( self.server.srvid, self.name ) ) > 0:
|
|
raise ValueError( _( "Another player already registered that name." ) );
|
|
if not self.password:
|
|
raise ValueError( _( "Cannot register player without a password!" ) );
|
|
|
|
self.mumbleid = ctl.registerPlayer( self.server.srvid, self.name, email, self.password );
|
|
|
|
# Update user's registration
|
|
elif self.password:
|
|
ctl.setRegistration(
|
|
self.server.srvid,
|
|
self.mumbleid,
|
|
self.name,
|
|
email,
|
|
self.password
|
|
);
|
|
|
|
# Don't save the users' passwords, we don't need them anyway
|
|
self.password = '';
|
|
|
|
self.setAdmin( self.isAdmin );
|
|
|
|
# Now allow django to save the record set
|
|
return models.Model.save( self );
|
|
|
|
|
|
# Admin handlers
|
|
|
|
def getAdmin( self ):
|
|
"""Get ACL of root Channel, get the admin group and see if this user is in it."""
|
|
acl = mmACL( 0, self.server.ctl.getACL(self.server.srvid, 0) );
|
|
|
|
if not hasattr( acl, "admingroup" ):
|
|
raise ReferenceError( _( "The admin group was not found in the ACL's groups list!" ) );
|
|
return self.mumbleid in acl.admingroup['add'];
|
|
|
|
def setAdmin( self, value ):
|
|
"""Set or revoke this user's membership in the admin group on the root channel."""
|
|
ctl = self.server.ctl;
|
|
acl = mmACL( 0, ctl.getACL(self.server.srvid, 0) );
|
|
|
|
if not hasattr( acl, "admingroup" ):
|
|
raise ReferenceError( _( "The admin group was not found in the ACL's groups list!" ) );
|
|
|
|
if value != ( self.mumbleid in acl.admingroup['add'] ):
|
|
if value:
|
|
acl.admingroup['add'].append( self.mumbleid );
|
|
else:
|
|
acl.admingroup['add'].remove( self.mumbleid );
|
|
|
|
ctl.setACL(self.server.srvid, acl);
|
|
return value;
|
|
|
|
|
|
# Texture handlers
|
|
|
|
def getTexture( self ):
|
|
"""Get the user texture as a PIL Image."""
|
|
return self.server.ctl.getTexture(self.server.srvid, self.mumbleid);
|
|
|
|
def setTexture( self, infile ):
|
|
"""Read an image from the infile and install it as the user's texture."""
|
|
self.server.ctl.setTexture(self.server.srvid, self.mumbleid, infile)
|
|
|
|
# Deletion handler
|
|
|
|
@staticmethod
|
|
def pre_delete_listener( **kwargs ):
|
|
kwargs['instance'].unregister();
|
|
|
|
def unregister( self ):
|
|
"""Delete this user account from Murmur."""
|
|
if self.getAdmin():
|
|
self.setAdmin( False );
|
|
self.server.ctl.unregisterPlayer(self.server.srvid, self.mumbleid)
|
|
|
|
|
|
# "server" field protection
|
|
|
|
def __setattr__( self, name, value ):
|
|
if name == 'server':
|
|
if self.id is not None and self.server != value:
|
|
raise AttributeError( _( "This field must not be updated once the record has been saved." ) );
|
|
|
|
models.Model.__setattr__( self, name, value );
|
|
|
|
|
|
|
|
|
|
from django.db.models import signals
|
|
|
|
signals.pre_delete.connect( Mumble.pre_delete_listener, sender=Mumble );
|
|
signals.pre_delete.connect( MumbleUser.pre_delete_listener, sender=MumbleUser );
|
|
|
|
|
|
|
|
|