More fixes for the alias registration.

- registration info saved on the hard drive
- doesn't return registration info for
  an already registered user

3 files changed, 132 insertions, 103 deletions

diff --git a/server/object.py b/server/object.py
index 5773f4f..91ec3c7 100644
--- a/server/object.py
+++ b/server/object.py
@@ -4,11 +4,8 @@ import hashlib
 import sys
 import os
 import os.path
-import zlib
-import datetime
 import fileinput
 import logging
-import pickle
 logger = logging.getLogger(__name__)
 
 from permission import *
@@ -18,18 +15,17 @@ class ObjectError(Exception):
     pass;
 
 class Object:
-    def __init__(self, owner, hash = None):
-        self.owner = owner
-        if hash is None:
-            hash = hashlib.sha1(owner).hexdigest()
+    def __init__(self, hash):
         self.hash = hash
-        self.owner_path = os.path.join(config.root, owner)
-        self.object_path = os.path.join(self.owner_path, hash[:2], hash[2:])
-        
+        self.object_path = os.path.join(config.root, hash[:2], hash[2:])
+
+    def exists(self):
+        return os.path.exists(self.object_path)
+
 class ObjectReader(Object):
-    def __init__(self, owner, hash = None):
-        Object.__init__(self, owner, hash)
-        if not os.path.exists(self.object_path):
+    def __init__(self, hash):
+        Object.__init__(self, hash)
+        if not self.exists():
             logger.error("Object {} can't be found for user {}".format(self.hash,
                                                                         self.owner))
             raise ObjectError
@@ -70,10 +66,9 @@ class ObjectReader(Object):
         for line in file:
             name = line.rstrip('\n')
             try:
-                child = ObjectReader(self.owner, name)
+                child = ObjectReader(name)
             except ObjectError:
-                logger.error("Object {} can't be find for user {}".format(self.hash,
-                                                                           self.owner))
+                logger.error('Object {} doesn\'t exist'.format(name))
             else:
                 perm, key = child.get_permission_key(user)
                 if perm > 0:
@@ -83,31 +78,65 @@ class ObjectReader(Object):
         return result
 
     def get_content(self, user):
+        """Return object content and the user key to decrypt it."""
         perm, key = self.get_permission_key(user)
         if not perm & READ :
             logger.error("User {} doesn't have read access to object {}"
                           .format(user, self.hash))
             raise PermissionError
+        with open(os.path.join(self.object_path, 'object'), 'r') as file:
+            content = {}
+            for line in file:
+                k, v = line.split()
+                content[k] = v
 
-        file = open(os.path.join(self.path, "object"), 'r')
-        content = file.read()
-        file.close()
-        return content, key
+        #return content, key
+        return content
+
+
+class ObjectWriter(ObjectReader):
     
-    def get_registration_data(self):
-        pass
+    def __init__(self, hash):
+        Object.__init__(self, hash)
+        #new object
+        if not self.exists():
+            os.makedirs(self.object_path)
+            for filename in ['permissions', 'children', 'object']:
+                file=open(os.path.join(self.object_path, filename), "w")
+                file.close()
+
+    def write(self, user, content):
+        perm = self.get_permission(user)
+        if not perm & MODIFY:
+            logger.error("User {} doesn't have the modify permission for object {}"
+                          .format(user, self.hash))
+            raise PermissionError
+        with open(os.path.join(self.object_path, 'object'), "w") as file:
+            for k, v in content:
+                file.write('{} {}'.format(k,v))
+
+    def append(self, user, content, parent):
+        parent_object = ObjectReader(parent)
+        perm = parent_object.get_permission(user)
+        if not perm & APPEND:
+            logger.error("User {} doesn't have the modify permission for object {}"
+                          .format(user, parent))
+            raise PermissionError
+        with open(os.path.join(self.object_path, 'object'), "w") as file:
+            for k, v in content:
+                file.write('{} {}\n'.format(k,v))
+        #add the child hash to the parent
+        with open(os.path.join(parent_object.object_path, 'children'), "a") as file:
+            file.write('{}\n'.format(self.hash))
+
+    def create_root_object(self, user, content):
+        with open(os.path.join(self.object_path, 'object'), "w") as file:
+            for k, v in content.iteritems():
+                file.write('{} {}\n'.format(k,v))
+        #give all the permissions to the user
+        with open(os.path.join(self.object_path, 'permissions'), "a") as file:
+            file.write('{} 15 xxxxxx\n'.format(user,v))
 
-class ObjectWriter(Object):
-    def __init__(self, owner, hash = None):
-        Object.__init__(self, owner, hash)
-        if not os.path.exists(self.owner_path):
-            logger.error("User {} is not registered".format(self.owner))
-        os.makedirs(self.object_path)
-        for filename in ['permissions', 'childs', 'object']:
-            file=open(os.path.join(self.object_path, filename), "w")
-            file.close()
-        
-        
 if __name__ == '__main__':
     pass
 
diff --git a/server/user.py b/server/user.py
index 3fbf55c..c6e6e87 100644
--- a/server/user.py
+++ b/server/user.py
@@ -4,44 +4,32 @@ import shutil
 import hashlib
 import logging
 logger = logging.getLogger(__name__)
-from object import ObjectWriter
+from object import *
 
-class UserHandler:
-
-    def __init__(self, root):
-        self.root = root
 
-    def register(self, jid, registration):
-        userDir = self.root + '/' + jid
-        if os.path.exists(userDir):
-            logger.error("User {} path already exists".format(jid))
-        os.mkdir(userDir)
-        ObjectWriter(jid)
-        return True
+class User:
 
-    def registered(self, jid):
-        return os.path.exists(self.root + '/' + jid)
+    def __init__(self, jid):
+        self.jid = jid
+        self.hash = hashlib.sha1(jid).hexdigest()
 
-    def unregister(self, jid):
-        shutil.rmtree(self.root + '/' + jid)
+    def register(self, registration):
+        ObjectWriter(self.hash).create_root_object(self.jid, registration)
 
-    def get_user_list(self):
-        return os.listdir(self.root)
+    def get_registration(self):
+        ObjectReader(self.hash).get_content(self.jid)
 
-def register(self, jid, registration):
-        username = registration['username']
+    def registered(self):
+        return Object(self.hash).exists()
 
-        def filter_usernames(user):
-            return user != jid and self.users[user]['username'] == username
+    def unregister(self, jid):
+        ObjectWriter(self.jid, self.hash).delete()
+        shutil.rmtree(self.root + '/' + jid)
 
-        conflicts = filter(filter_usernames, self.users.keys())
-        if conflicts:
-            return False
+class UserHandler:
 
-        self.users[jid] = registration
-        return True
-class User:
+    def __init__(self,root):
+        self.root = root
 
-    def __init__(self, name):
-        self.name = name
-        self.rootObject = hashlib.sha1(name).hexdigest()
+    def get_user_list(self):
+        return os.listdir(self.root)
diff --git a/server/xep_0077.py b/server/xep_0077.py
index 8590bb4..6018c55 100644
--- a/server/xep_0077.py
+++ b/server/xep_0077.py
@@ -10,7 +10,7 @@ from sleekxmpp.xmlstream.handler.callback import Callback
 from sleekxmpp.xmlstream.matcher.xpath import MatchXPath
 from sleekxmpp.xmlstream import ElementBase, ET, register_stanza_plugin
 from sleekxmpp import Iq
-from user import UserHandler
+from user import User
 from config import config
 from sleekxmpp.plugins.xep_0004 import Form
 
@@ -18,43 +18,42 @@ class Registration(ElementBase):
     namespace = 'jabber:iq:register'
     name = 'query'
     plugin_attrib = 'register'
-    interfaces = set(('registered', 'remove', 'instructions', 'form'))
+    interfaces = set(('registered', 'remove', 'instructions'))
     sub_interfaces = interfaces
     subitem = (Form,)
 
-    def getRegistered(self):
+    def get_registered(self):
         present = self.xml.find('{%s}registered' % self.namespace)
         return present is not None
 
-    def getRemove(self):
+    def get_remove(self):
         present = self.xml.find('{%s}remove' % self.namespace)
         return present is not None
 
-    def setRegistered(self, registered):
+    def set_registered(self, registered):
         if registered:
-            self.addField('registered')
+            self.add_field('registered')
         else:
             del self['registered']
 
-    def setRemove(self, remove):
+    def set_remove(self, remove):
         if remove:
             self.addField('remove')
         else:
             del self['remove']
 
-    def addField(self, name):
+    def add_field(self, name):
         itemXML = ET.Element('{%s}%s' % (self.namespace, name))
         self.xml.append(itemXML)
 
-    def addForm(self):
+    def add_form(self, values=None):
         aliasform = Form(None,self)
-        aliasform.addField(ftype="hidden",var="FORM_TYPE",value="jabber:iq:register")
+        aliasform.addField(ftype="hidden",var="FORM_TYPE",value=self.namespace)
         aliasform.addField(var="pubkey",ftype="text-single", label="Public Key", required=True)
         aliasform.addField(var="privkey",ftype="text-single", label="Private Key", required=True)
         aliasform.addField(var="salt",ftype="text-single", label="Salt", required=True)
-
-    def getForm(self):
-        self.xml.findall('{jabber:x:data}field')
+        if values:
+            aliasform.setValues(values)
 
 class xep_0077(base_plugin):
     """
@@ -64,80 +63,93 @@ class xep_0077(base_plugin):
     def plugin_init(self):
         self.description = "In-Band Registration"
         self.xep = "0077"
-        self.form_fields = ()
+        self.form_fields = ("privkey", "pubkey", "salt")
         self.form_instructions = "Please provide the following information to register\
                                   an alias account"
-        self.backend = None
 
-        self.xmpp.registerHandler(
+        self.xmpp.register_handler(
             Callback('In-Band Registration',
                      MatchXPath('{%s}iq/{jabber:iq:register}query' % self.xmpp.default_ns),
-                     self.__handleRegistration))
+                     self.__handle_registration))
         register_stanza_plugin(Iq, Registration)
 
     def post_init(self):
         base_plugin.post_init(self)
         self.xmpp['xep_0030'].add_feature("jabber:iq:register")
 
-    def __handleRegistration(self, iq):
+    def __handle_registration(self, iq):
+        registrant = User(iq['from'].bare)
         if iq['type'] == 'get':
             # Registration form requested
-            self.sendRegistrationForm(iq, self.backend)
+            self.send_registration_form(iq, registrant)
         elif iq['type'] == 'set':
             if iq['register']['remove']:
                 # Remove an account
-                self.backend.unregister(iq['from'].bare)
-                #self.xmpp.event('unregistered_user', iq)
+                registrant.unregister()
+                self.xmpp.event('unregistered_user', iq)
                 iq.reply().send()
                 return
 
             aliasforms = iq['register']['substanzas']
             for aliasform in aliasforms:
                 aliasdict = aliasform.getValues()
-
             for field in self.form_fields:
                 if not aliasdict[field]:
                     # Incomplete Registration
-                    self._sendError(iq, '406', 'modify', 'not-acceptable',
+                    self._send_error(iq, '406', 'modify', 'not-acceptable',
                                     "Please fill in all fields.")
                     return
 
-            #if self.backend.register(iq['from'].bare, iq['register']):
+            try:
+                print aliasdict
+                registrant.register(aliasdict)
                 # Successful registration
                 #self.xmpp.event('registered_user', iq)
-            iq.reply().setPayload(iq['register'].xml)
-            iq.send()
-            #else:
+                iq.reply().setPayload(iq['register'].xml)
+                iq.send()
+            except:
+                return
+            else:
                 # Conflicting registration
-            #    self._sendError(iq, '409', 'cancel', 'conflict',
-#                                "That username is already taken.")
+                self._send_error(iq, '409', 'cancel', 'conflict',
+                                "That username is already taken.")
 
     def setForm(self, *fields):
         self.form_fields = fields
 
-    def setInstructions(self, instructions):
+    def set_instructions(self, instructions):
         self.form_instructions = instructions
 
-    def sendRegistrationForm(self, iq, userData=None):
+    def send_registration_form(self, iq, registrant):
         reg = iq['register']
-        if userData is None:
-            userData = {}
-        else:
-            reg['registered'] = True
-
         if self.form_instructions:
             reg['instructions'] = self.form_instructions
 
-        reg.addForm()
+        if registrant.registered():
+            print "yoyoyo"
+            print registrant.get_registration()
+            reg['registered'] = True
+            reg.add_form(registrant.get_registration())
+        else:
+            reg.add_form()
 
         iq.reply().setPayload(reg.xml)
         iq.send()
 
-    def _sendError(self, iq, code, error_type, name, text=''):
+    def _send_error(self, iq, code, error_type, name, text=''):
         iq.reply().setPayload(iq['register'].xml)
         iq.error()
         iq['error']['code'] = code
         iq['error']['type'] = error_type
         iq['error']['condition'] = name
         iq['error']['text'] = text
-        iq.send()
\ No newline at end of file
+        iq.send()
+
+if __name__=='__main__':
+    test = Registration()
+    test.add_form()
+    test['registered']=True
+    print test
+    #why doesn't this work?
+    form = test.xml.findall('{jabber:x:data}x')
+    print form