source: n4d-server-plugins/trunk/fuentes/server-install-files/usr/share/n4d/python-plugins/LdapManager.py @ 4994

Last change on this file since 4994 was 4994, checked in by hectorgh, 2 years ago

read changelog

File size: 49.8 KB
Line 
1# -*- coding: utf-8 -*-
2
3import ldap
4import subprocess
5import base64,random,hashlib,string
6import xml.etree
7import xml.etree.ElementTree
8import sys
9import threading
10import time
11import smbpasswd
12import grp
13
14
15import unicodedata
16import syslog
17
18import os
19import os.path
20
21
22base_home_dir="/home/"
23
24LDAP_LOG="/var/log/n4d/ldap"
25
26#uid=pepe,ou=Admins,ou=People,dc=ma5,dc=lliurex,dc=net
27#lliurex
28
29def getLliurexVariables():
30       
31        try:
32       
33                p1=subprocess.Popen(["llxcfg-listvars","--values"],stdout=subprocess.PIPE)
34               
35                output=p1.communicate()[0]
36                output=output.replace("'","")           
37
38                tmp1=output.split(';\n')
39
40                dic={}
41
42                for item in tmp1:
43                        tmp2=item.split('=',1)
44                               
45                        if len(tmp2)>1:
46                                dic[tmp2[0]]=tmp2[1]   
47                               
48        except:
49                dic={}
50                dic["LDAP_BASE_DN"]="dc=ma5,dc=lliurex,dc=net"
51
52        return dic
53
54
55
56
57
58
59class GescenItem:
60       
61        def __init__(self):
62               
63                self.attributes={}
64               
65        #def init
66       
67        def print_me(self):
68               
69                print(self.attributes)
70               
71        #def print_me
72       
73#class GescenItem
74
75
76
77class LdapUser:
78       
79        def __init__(self,properties):
80               
81
82                #list=['top', 'posixAccount', 'shadowAccount', 'person', 'sabayonProfileNameObject','x-lliurex-user']
83                list=['top','person', 'sambaSamAccount','posixAccount','shadowAccount','x-lliurex-user']
84               
85                self.properties={}
86                '''
87                for key in properties:
88                        self.properties[key]=properties[key]
89                '''
90                self.properties=properties.copy()
91                self.uid=self.properties["uid"]
92               
93                if not self.properties.has_key("description"):
94                        self.properties["description"]=self.properties["cn"] + " " + self.properties["sn"]
95               
96                self.properties["objectClass"]=list
97                self.properties["loginShell"]="/bin/bash"
98                self.properties["homeDirectory"]="/home/"+self.uid
99               
100                #SAMBA STUFF
101                self.properties['sambaHomePath']="\\\\"+self.uid
102                self.properties['sambaProfilePath']="\\\\profiles\\"+self.uid
103                self.properties['sambaAcctFlags']='[U]'
104                self.properties['gecos']=self.uid
105               
106               
107                self.banned_list=['path','password','profile']
108               
109
110               
111        def get_modlist(self,banned_list=None):
112               
113                list=[]
114               
115                if banned_list==None:
116                        banned_list=self.banned_list
117               
118                for key in self.properties:
119                        if key not in banned_list:
120                                list.append((key,self.properties[key]))
121
122                return list
123               
124               
125        #def get_modlist
126               
127               
128               
129               
130        def print_me(self):
131               
132               
133                print(self.properties)
134               
135       
136#class LdapUSer
137
138
139
140def strip_accents(s):
141        return ''.join((c for c in unicodedata.normalize('NFD', s) if unicodedata.category(c) != 'Mn'))
142
143
144def ldapmanager_connect(f):
145        def wrap(*args,**kw):
146                args[0].connect()
147                return f(*args)
148        return wrap
149#def __try_connect__
150
151
152class LdapGroup:
153       
154        def __init__(self,properties):
155               
156                self.attributes=[]
157                #list=['top', 'posixGroup', 'lisGroup','x-lliurex-group']
158                list=['top', 'posixGroup','x-lliurex-group','sambaGroupMapping']
159                self.cn=properties["cn"]
160               
161                self.properties=properties
162               
163                if not self.properties.has_key("description"):
164                        self.properties["description"]=self.cn
165                        description=self.cn
166                       
167                self.properties["objectClass"]=list
168               
169                for key in self.properties:
170                        self.attributes.append((key,self.properties[key]))
171                       
172                #self.attributes.append(('groupType','school_class'))
173               
174               
175
176               
177        #def __init__
178       
179        def print_me(self):
180               
181                print(self.properties)
182       
183#class LdapGroup
184
185
186
187class LdapManager:
188
189
190        RANDOM_PASSWORDS=0
191        SAME_PASSWORD=1
192        PASS_EQUALS_USER=2
193       
194        LDAP_SECRET1="/etc/lliurex-cap-secrets/ldap-master/ldap"
195        LDAP_SECRET2="/etc/lliurex-secrets/passgen/ldap.secret"
196       
197        SAMBASID_FILE="/etc/n4d/sambaid"
198       
199       
200       
201        def __init__(self,llxvar):
202               
203                print("[LDAPMANAGER] INIT")
204                self.llxvar=llxvar
205                self.restore_connection=True
206                self.reset_connection_variable()
207                self.get_samba_id()
208               
209                #self.getLliurexVariables()
210               
211                try:
212                        self.connect()
213                        self.get_xid_counters()
214                        self.get_xgid_counter()
215                except Exception as e:
216                        print(e)
217                        self.log("__init__",e)
218                        self.connection=False
219
220        #def init
221       
222
223
224        def reset_connection_variable(self):
225               
226                url=self.llxvar("MASTER_SERVER_IP")
227               
228                if url!=None:
229               
230                        print("[LDAPMANAGER] Starting connection thread...")
231                        t=threading.Thread(target=self._rcv_thread)
232                        t.daemon=True
233                        t.start()
234               
235        #def reset_connection_variable
236       
237        def _rcv_thread(self):
238               
239                while True:
240               
241                        time.sleep(90)
242                        print("[LDAPMANAGER] Restoring connection variable...")
243                        self.restore_connection=True
244               
245               
246        #def _rcv_thread
247
248       
249        def log(self,function_name,exception,comment=None):
250               
251                try:
252                        f=open(LDAP_LOG,"a")
253                        f.write("* When calling " + function_name + " something happened...\n\t")
254                        f.write(str(exception))
255                        f.write("\n")
256                        if comment!=None:
257                                f.write("\tCoder Hint: " + str(comment))
258                                f.write("\n")
259                        f.close()
260                except:
261                        pass
262               
263        #def log
264       
265       
266        @ldapmanager_connect
267        def get_xid_counters(self,uid="*"):
268               
269                result=self.ldap.search_s("ou=People,"+self.llxvar("LDAP_BASE_DN"),ldap.SCOPE_SUBTREE)
270               
271                self.xid_counters={}
272               
273                for item in result:
274                        path,properties_dic=item
275                        if "x-lliurex-ou-properties" in  properties_dic['objectClass'] and properties_dic.has_key("x-lliurex-xid-counter"):
276                                self.xid_counters[properties_dic['ou'][0]]=properties_dic['x-lliurex-xid-counter'][0]
277               
278               
279               
280               
281        #def get_counter
282       
283        @ldapmanager_connect
284        def get_xgid_counter(self):
285               
286                self.xgid_counter=None
287               
288                result=self.ldap.search_s("ou=Managed,ou=Groups,"+self.llxvar("LDAP_BASE_DN"),ldap.SCOPE_SUBTREE)
289                for item in result:
290                        path,properties_dic=item
291                        if "x-lliurex-ou-properties" in properties_dic["objectClass"] and properties_dic.has_key("x-lliurex-xid-counter"):
292                                self.xgid_counter=properties_dic['x-lliurex-xid-counter'][0]
293                               
294        #def get_xgid_counter
295       
296        @ldapmanager_connect
297        def set_next_xid(self,ou):
298               
299                try:
300                        value=int(self.xid_counters[ou])
301                        value+=1
302               
303                        mod=( ldap.MOD_REPLACE, "x-lliurex-xid-counter", str(value) )
304                        mod_list=[]
305                        mod_list.append(mod)
306                        path="ou="+ou+",ou=People," + self.llxvar("LDAP_BASE_DN")
307                        self.ldap.modify_s(path,mod_list)
308                        self.xid_counters[ou]=str(value)
309                        return [True,str(value)]
310                except Exception as e:
311                        self.log("set_next_xid",e)
312                        return [False,e]
313               
314               
315        #def set_next_xid_counter
316       
317       
318        @ldapmanager_connect
319        def set_xid(self,ou,value):
320               
321                mod=( ldap.MOD_REPLACE, "x-lliurex-xid-counter", str(value) )
322                mod_list=[]
323                mod_list.append(mod)
324                path="ou="+ou+",ou=People," + self.llxvar("LDAP_BASE_DN")
325                try:
326                        self.ldap.modify_s(path,mod_list)
327                        return True
328                except Exception as e:
329                        #print e
330                        self.log("set_xid",e)
331                        return [False,e]
332               
333        #def set_xid_counter
334       
335        @ldapmanager_connect
336        def set_next_xgid(self):
337               
338                try:
339                        value=int(self.xgid_counter)
340                        value+=1
341               
342                        mod=( ldap.MOD_REPLACE, "x-lliurex-xid-counter", str(value) )
343                        mod_list=[]
344                        mod_list.append(mod)
345                        path="ou=Managed,ou=Groups," + self.llxvar("LDAP_BASE_DN")
346                        self.ldap.modify_s(path,mod_list)
347                        self.xgid_counter=str(value)
348                        return [True,str(value)]
349                except Exception as e:
350                        self.log("set_next_xgid",e)
351                        return [False,e]
352               
353               
354        #def set_next_xid_counter
355       
356       
357       
358        def get_samba_id(self):
359
360                self.samba_id=None
361                self.get_samba_id_first_run=False
362                t=threading.Thread(target=self.get_samba_id_t)
363                t.daemon=True
364                t.start()
365               
366        #def get_samba_id
367       
368       
369        def get_samba_id_t(self):
370               
371                for count in range(0,10):
372               
373                        try:
374                                pprocess = subprocess.Popen(['net','getlocalsid'],stderr=subprocess.PIPE,stdout=subprocess.PIPE)
375                                sambaid = pprocess.communicate()[0]
376                                aux = sambaid.split(":")[1]
377                                self.samba_id = aux[1:len(aux)-1]
378                                self.get_samba_id_first_run=True
379                                print("[LDAPMANAGER] Samba ID ready.")
380                                return True
381                        except Exception as e:
382                                print("[LDAPMANAGER] Get Samba ID failed: %s.")
383                                if count < 9:
384                                        print("[LDAPMANAGER] Retrying in 2 sec...")
385                                        time.sleep(2)
386
387                self.get_samba_id_first_run=True
388                return False
389               
390               
391        #def get_samba_id_t
392       
393       
394       
395        def getsalt(self,chars = string.letters + string.digits,length=16):
396               
397                salt = ""
398                for i in range(int(length)):
399                        salt += random.choice(chars)
400                return salt
401               
402        #def getsalt
403
404       
405        def generate_random_ssha_password(self):
406                password="".join(random.sample(string.letters+string.digits, 4))
407                return self.generate_ssha_password(password),password
408               
409        #def generate_random_ssha_password
410       
411        def generate_ssha_password(self,password):
412               
413                salt=self.getsalt()
414                return "{SSHA}" + base64.encodestring(hashlib.sha1(str(password) + salt).digest() + salt)
415               
416        #def generate_ssha_password     
417       
418       
419        def getLliurexVariables(self):
420               
421                p1=subprocess.Popen(["llxcfg-listvars","--values"],stdout=subprocess.PIPE)
422               
423                output=p1.communicate()[0]
424                output=output.replace("'","")           
425
426                tmp1=output.split(';\n')
427               
428                for item in tmp1:
429                        tmp2=item.split('=',1)
430                       
431                        if len(tmp2)>1:
432                                self.llxvar[tmp2[0]]=tmp2[1]           
433               
434        # getLliurexVariables
435       
436       
437        def generate_uid(self,name,surname):
438               
439                name_list=name.split(" ")
440                surname_list=surname.split(" ")
441               
442                uid=""
443               
444                for i in range(0,len(name_list[0])):
445                        uid=uid+name_list[0][i]
446                        if len(uid)==3:
447                                break
448                               
449                last_surname=len(surname_list)-1
450                for i in range(0,len(surname_list[last_surname])):
451                        uid=uid+surname_list[last_surname][i]
452                        if len(uid)==6:
453                                break
454                       
455                return uid
456               
457               
458        #def generateUid
459       
460       
461        def parseGescen(self,path):
462               
463                document=xml.etree.ElementTree.parse(path)
464                root=document.getroot()
465
466                alumnes=[]
467                cursos=[]
468                for node in root:
469                        if node.tag=="alumnes":
470                                alumnes=node.getchildren()
471                        if node.tag=="grups":
472                                cursos=node.getchildren()
473
474
475                parsed_subjects=[]
476                if len(cursos)>0:
477                        for curs in cursos:
478                                subject=GescenItem()
479                                items=curs.getchildren()
480                                for item in items:
481                                        subject.attributes[item.tag]=item.text
482                                       
483                                parsed_subjects.append(subject)
484                                       
485
486
487                parsed_students=[]
488                if len(alumnes)>0:
489                        for alumne in alumnes:
490                                student=GescenItem()
491                                items=alumne.getchildren()
492                                for item in items:
493                                        student.attributes[item.tag]=item.text
494                                       
495                                       
496                                parsed_students.append(student)
497
498                               
499                if len(parsed_subjects)>0:
500                        for subject in parsed_subjects:
501                                codi=unicode(subject.attributes["codi"]).encode("ascii")
502                                nom=unicode(subject.attributes["nom"]).encode("utf-8")
503                                prop={}
504                                prop["cn"]=codi
505                                prop["description"]=nom
506                                prop["x-lliurex-grouptype"]="itaca"
507                                self.add_group(prop)
508                               
509                               
510                if len(parsed_students)>0:
511                        for student in parsed_students:
512                                name_utf_encoded=False
513                                surname_utf_encoded=False
514                               
515                                name=strip_accents(unicode(student.attributes["nom"])).lower()
516                                name=unicode(name).encode("ascii")
517                                surname=strip_accents(unicode(student.attributes["cognoms"])).lower()
518                                surname=unicode(surname).encode("ascii")
519                               
520                                # // Generate uid
521                               
522                                uid=self.generate_uid(name,surname)
523                                '''
524                                uid=""
525                                count=0
526                                for char in name:
527                                        if count<3:
528                                                uid=uid+char
529                                                count+=1
530                                        else:
531                                                break
532                                count=0
533                                for char in surname:
534                                        if count<3:
535                                                uid=uid+char
536                                                count+=1
537                                        else:
538                                                break
539                                '''
540                               
541                                # // Generate uid
542                               
543                               
544                                group=unicode(student.attributes["grup"]).encode("ascii")
545
546                               
547                                if uid.find(" ")!=-1:
548                                        uid=uid.replace(" ","")
549
550                                name=unicode(student.attributes["nom"]).encode("utf-8")
551                                surname=unicode(student.attributes["cognoms"]).encode("utf-8")
552                               
553                               
554                                properties={}
555                                properties["uid"]=uid
556                                properties["cn"]=name
557                                properties["sn"]=surname
558                                properties["password"]=uid
559                               
560                                generated_user=self.add_user(True,"Students",properties)
561                                #print self.add_to_group_type(group,generated_user["uid"])
562               
563
564        #def parseGescen
565       
566       
567        def connect(self):
568       
569                if self.get_samba_id_first_run and self.samba_id==None:
570                        # Calling blocking call instead of thread
571                        self.get_samba_id_t()
572               
573                if self.restore_connection:
574                        self.restore_connection=False
575                        sys.stdout.write("[LDAPMANAGER] Connecting to ldap ... ")
576                        url=None
577                        remote=False
578                        try:
579                                url=self.llxvar("MASTER_SERVER_IP")
580                                if url!=None:
581                                        url="ldap://"+url
582                                        remote=True
583                        except Exception as e:
584                                print(e,"")
585                       
586                        do_it=True
587                       
588                        if not remote:
589                       
590                                try:
591                                        #url=self.llxvar("CLIENT_LDAP_URI")
592                                        url="ldaps://localhost"
593                                        count=1
594                                except Exception as e:
595                                        print(e,"")
596                                        return None
597                                       
598                        else:
599                                count=2
600                       
601                        for x in range(0,count):
602                       
603                                try:
604                               
605                                        self.ldap=ldap.initialize(url)
606                                        self.ldap.set_option(ldap.VERSION,ldap.VERSION3)
607                                       
608                                        if os.path.exists(LdapManager.LDAP_SECRET1):
609                                                f=open(LdapManager.LDAP_SECRET1)
610                                                lines=f.readlines()
611                                                f.close()
612                                                password=lines[0].replace("\n","")
613                                        else:
614                                                if os.path.exists(LdapManager.LDAP_SECRET2):
615                                                        f=open(LdapManager.LDAP_SECRET2)
616                                                        lines=f.readlines()
617                                                        f.close()
618                                                        password=lines[0].replace("\n","")
619                                       
620       
621                                        #path="uid=lliurex," + self.llxvar("LDAP_ADMIN_PEOPLE_BASE_DN")
622                                        try:
623                                                path="cn=admin,"+self.llxvar("LDAP_BASE_DN")
624                                        except:
625                                                return None
626                                                #path="uid=pepe,ou=Admins,ou=People,dc=ma5,dc=lliurex,dc=net"
627                                       
628                                        self.ldap.bind_s(path,password)
629                                        print("OK")
630                                       
631                                        return True
632                                       
633                                       
634                                except Exception as l_ex:
635                                        print l_ex
636                                        try:
637                                                url=self.llxvar("CLIENT_LDAP_URI")
638                                        except Exception as e:
639                                                print(e,"")
640                                                return None
641                                               
642                        print("[LDAPMANAGER] Error connecting to ldap")
643                       
644               
645               
646               
647        #def connect
648       
649       
650        def print_list(self):
651               
652               
653                a=self.ldap.search_s(self.llxvar("LDAP_BASE_DN"),ldap.SCOPE_SUBTREE,'sn='+'*')
654                count=1
655                for item in a:
656                        print(count)
657                        count+=1
658                        print(item)
659                               
660               
661        #def print_list
662       
663        @ldapmanager_connect
664        def add_user(self,generic_mode,plantille,properties):
665               
666                uid=properties["uid"]
667                user=LdapUser(properties)
668                cn=""
669               
670               
671                if (plantille=="Students"):
672                       
673                        try:
674                                groupinfo=grp.getgrnam('students')
675                                gidNumber=groupinfo[2]
676                                user.properties["gidNumber"]=str(gidNumber)                     
677                        except Exception as e:
678                                self.log("add_user",e)
679                                #return "false"
680                                # \/ this should not be here \/
681                                user.properties["gidNumber"]="234"
682                                # /\ ==============  /\
683                                               
684                        user.properties["profile"]="students"
685                        user.properties['sambaPrimaryGroupSID']=self.samba_id+"-"+user.properties["gidNumber"]
686                        cn="stuID"
687                       
688                        if not properties.has_key("userPassword"):
689                                password="".join(random.sample(string.letters+string.digits, 4))
690                                user.properties["userPassword"]=password
691                       
692                elif (plantille=="Teachers"):
693
694                        groupinfo=grp.getgrnam('teachers')
695                        gidNumber=groupinfo[2]
696                        user.properties["gidNumber"]=str(gidNumber)
697                        user.properties["profile"]="teachers"
698                        cn="teaID"
699                       
700                        if  not properties.has_key("userPassword"):
701                                ssha_password,password=self.generate_random_ssha_password()
702                                user.properties["userPassword"]=password
703
704                elif (plantille=="Other"):
705
706                        groupinfo=grp.getgrnam('others')
707                        gidNumber=groupinfo[2]
708                        user.properties["gidNumber"]=str(gidNumber)
709                        user.properties["profile"]="others"
710                        cn="otID"
711               
712                        if  not properties.has_key("userPassword"):
713                                ssha_password,password=self.generate_random_ssha_password()
714                                user.properties["userPassword"]=password
715
716       
717                elif (plantille=="Admin"):
718                       
719                        #user.properties["sabayonProfileName"]="admin"
720                        p1=subprocess.Popen(["lliurex-userfuncs","llx_get_group_gid","admin"],stdout=subprocess.PIPE)
721                        output=p1.communicate()[0]
722                        gidNumber=output.replace("\n","")
723                        user.properties["gidNumber"]=str(gidNumber)
724                        user.properties["profile"]="admins"
725                        cn="otID"
726               
727                        if  not properties.has_key("userPassword"):
728                                ssha_password,password=self.generate_random_ssha_password()
729                                user.properties["userPassword"]=password       
730                               
731                if user.properties.has_key("userPassword"):
732                        password=user.properties['userPassword']
733                       
734                #else password variable should be available... it SHOULD
735               
736                if "sambaNTPassword" not in user.properties:
737                        user.properties['sambaNTPassword']=smbpasswd.nthash(password)
738                if "sambaLMPassword" not in user.properties:
739                        user.properties['sambaLMPassword']=smbpasswd.lmhash(password)
740                       
741                user.properties['sambaPwdLastSet']=str(int(time.time()))
742               
743                path="uid="+user.uid+","+ "ou="+plantille+",ou=People," + self.llxvar("LDAP_BASE_DN")
744                user.properties["path"]=path
745                if not user.properties.has_key("uidNumber"):
746                        ret,uidNumber=self.set_next_xid(plantille)
747                        if ret==False:
748                                #uidNumber is an exception in this case
749                                return uidNumber.message
750                        user.properties["uidNumber"]=str(uidNumber)
751                else:
752                        uidNumber=user.properties["uidNumber"]
753                       
754                user.properties['sambaSID']=self.samba_id+"-"+user.properties["uidNumber"]
755               
756
757               
758
759                # ADD USER
760
761                try:
762                        user_list=self.search_user(uid)
763                        if len(user_list)>0:
764                                raise ldap.ALREADY_EXISTS
765                               
766                        self.ldap.add_s(path,user.get_modlist())
767                        group_list=self.add_to_generic_groups(plantille,user)
768                        if group_list!=None:
769                                user.properties["groups"]=group_list
770                       
771                        return user.properties
772                       
773                except Exception as exc:
774                       
775                       
776                        if type(exc)==ldap.ALREADY_EXISTS:
777                                if not generic_mode:
778                                        return "User already exists"
779                                else:
780                                       
781                                        count=0
782                                        integer_found=False
783                                       
784                                       
785                                        counter=len(uid)-1
786                                       
787                                        for pos in range(-len(uid)+1,1):
788                                                try:
789                                                        integer=int(uid[pos*-1])
790                                                        counter-=1
791                                                except:
792                                                        break   
793                                                       
794                                        uid=uid[:counter+1]
795
796                                        user_list=self.search_user(uid+"*")
797                                        index_list=[]
798                                        for item in user_list:
799                                                list=item.uid.split(uid)
800                                                if len(list)>1 and len(list[1])>0:
801                                                        try:
802                                                                lets_try=int(list[1])
803                                                                index_list.append(lets_try)
804                                                               
805                                                        except:
806                                                                pass
807                                       
808                                        index_list.sort()
809                                        if len(index_list)>0:
810                                                id=int(index_list[len(index_list)-1])
811                                                id+=1
812                                        else:
813                                                id=1
814                                               
815                                        value=str(id)
816                                        if id<10:
817                                                value="0"+str(id)
818                                               
819                                       
820                                        nonum_uid=uid
821                                        uid=uid+value
822                                        #print "Calculated uid: " + uid
823                                        new_uid=uid
824                                        new_attributes=[]
825                                       
826                                        user.properties["uid"]=new_uid
827                                        user.properties["homeDirectory"]=base_home_dir+new_uid
828                                        user.properties["gecos"]=new_uid
829                                        user.properties['sambaHomePath']='\\'+new_uid
830                                        user.properties['sambaProfilePath']='\\\\profiles\\'+new_uid
831                                               
832                                        if generic_mode:
833                                                if user.properties["cn"].find(nonum_uid)!=-1:
834                                                        user.properties["cn"]=new_uid
835                                                               
836                                                if user.properties["sn"].find(nonum_uid)!=-1:
837                                                        user.properties["sn"]=new_uid
838                                               
839                                                if user.properties["description"].find(nonum_uid)!=-1:
840                                                        user.properties["description"]=new_uid
841                                               
842
843                                        user.uid=new_uid
844                                        user.properties["uid"]=new_uid
845                                        path="uid="+user.uid+","+ "ou="+plantille+",ou=People," + self.llxvar("LDAP_BASE_DN")
846                                        user.properties["path"]=path
847
848                                       
849                                        #print user.get_modlist()
850                                        try:
851                                                self.ldap.add_s(path,user.get_modlist())
852                                                group_list=self.add_to_generic_groups(plantille,user)
853                                                if group_list!=None:
854                                                        user.properties["groups"]=group_list
855                                                #print group_list
856                                                return user.properties
857                                               
858                                        except Exception as inst:
859                                                #print(inst)
860                                                self.log("add_user",inst,"ldap.ALREADY_EXISTS branch")
861                                                return inst[0]["desc"]
862       
863
864                        else:
865                                #print(exc)
866                                self.log("add_user",exc)
867                                return exc[0]["desc"]
868
869        #def add_user_def
870       
871       
872       
873        @ldapmanager_connect
874        def set_next_id(self,cn,gidNumber=None):
875                if gidNumber==None:
876                        mod=( ldap.MOD_REPLACE, 'gidNumber', str(self.get_next_id(cn)+1) )
877                else:
878                        mod=( ldap.MOD_REPLACE, 'gidNumber', str(gidNumber) )
879                       
880                mod_list=[]
881                mod_list.append(mod)
882                path="cn="+cn+",ou=Variables," + self.llxvar("LDAP_BASE_DN")
883               
884                self.ldap.modify_s(path,mod_list)               
885               
886        #def update_user_count_variable
887
888        @ldapmanager_connect
889        def get_next_id(self,cn):
890               
891                path="cn="+cn+",ou=Variables," + self.llxvar("LDAP_BASE_DN")
892               
893                a=self.ldap.search_s(path,ldap.SCOPE_SUBTREE)
894               
895                for x,y in a:
896                        if y.has_key('gidNumber'): 
897                                return int(y['gidNumber'][0])
898                               
899               
900        #def get_next_id
901               
902        @ldapmanager_connect
903        def modify_value(self,path,field,value):
904               
905                mod=( ldap.MOD_REPLACE, field, value )
906                mod_list=[]
907                mod_list.append(mod)
908                try:
909                        self.ldap.modify_s(path,mod_list)
910                        return "true"
911                except Exception as e:
912                        self.log("modify_value",e)
913                        return e[0]["desc"]
914                       
915               
916        #def modify_value
917       
918       
919        @ldapmanager_connect
920        def change_group_description(self,gid,description):
921               
922                mod=( ldap.MOD_REPLACE, "description", description )
923                mod_list=[]
924                mod_list.append(mod)                     
925                path="cn="+gid+",ou=Managed,ou=Groups," + self.llxvar("LDAP_BASE_DN")
926                try:
927                        self.ldap.modify_s(path,mod_list)
928                        return "true"
929                except Exception as e:
930                        #print e
931                        self.log("change_group_description",e)
932                        return e[0]["desc"]                             
933               
934               
935        #def change_group_description
936       
937        @ldapmanager_connect
938        def change_student_name(self,uid,name):
939                #print "change student name!!!!!!"     
940       
941                       
942                mod=( ldap.MOD_REPLACE, "cn", name )
943                mod_list=[]
944                mod_list.append(mod)
945                path="uid="+uid+","+ "ou=Students,ou=People," + self.llxvar("LDAP_BASE_DN")
946                try:
947                        self.ldap.modify_s(path,mod_list)
948                        return "true"
949                except Exception as e:
950                        self.log("change_student_name",e)
951                        return e[0]["desc"]             
952               
953               
954        #def change_student_name
955       
956
957       
958        @ldapmanager_connect
959        def change_student_surname(self,uid,surname):
960               
961                #surname=unicode(surname).encode("utf-8")
962                mod=( ldap.MOD_REPLACE, "sn", surname )
963                mod_list=[]
964                mod_list.append(mod)
965                path="uid="+uid+","+ "ou=Students,ou=People," + self.llxvar("LDAP_BASE_DN")
966                try:
967                        self.ldap.modify_s(path,mod_list)
968                        return "true"
969                except Exception as e:
970                        self.log("change_student_surname",e)
971                        return e[0]["desc"]             
972               
973               
974        #def change_student_name
975       
976
977
978        @ldapmanager_connect
979        def change_password(self,path,password):
980               
981                try:
982                        password=unicode(password).encode("utf-8")
983                        if path.find("Students")!=-1:
984                                self.modify_value(path,"userPassword",password)
985                        else:
986                                self.modify_value(path,"userPassword",self.generate_ssha_password(password))
987                               
988                        self.modify_value(path,"sambaNTPassword",smbpasswd.nthash(password))
989                        self.modify_value(path,"sambaLMPassword",smbpasswd.lmhash(password))
990                        self.modify_value(path,"sambaPwdLastSet",str(int(time.time())))
991                               
992                        return "true"
993                except Exception as e:
994                        self.log("change_password",e)
995                        return e[0]["desc"]
996                       
997               
998        #def modify_value       
999       
1000        @ldapmanager_connect
1001        def change_user_password(self,uid,password):
1002               
1003                students="ou=Students,ou=People," + self.llxvar("LDAP_BASE_DN")
1004                path="uid="+uid+","+students
1005                return self.change_password(path,password)
1006               
1007        #def change_student_password
1008       
1009        @ldapmanager_connect
1010        def generic_student_to_itaca(self,uid,nia):
1011               
1012                students="ou=Students,ou=People," + self.llxvar("LDAP_BASE_DN")
1013                path="uid="+uid+","+students
1014                try:
1015                        mod_list=[]
1016                        #print "per que 0"
1017                        mod=( ldap.MOD_REPLACE, "x-lliurex-usertype", "itaca" )
1018                        #print "per que 1"
1019                        mod_list.append(mod)
1020                        #print "per que"
1021                        mod=( ldap.MOD_ADD, "x-lliurex-nia", str(nia) )
1022                        mod_list.append(mod)
1023                        #print "vamos a ver"
1024                        self.ldap.modify_s(path,mod_list)
1025                        #print "okay makey"
1026                        return "true"
1027                       
1028                except Exception as e:
1029                        self.log("generic_student_to_itaca",e)
1030                        return e[0]["desc"]     
1031
1032               
1033        #def generic_student_to_itaca
1034       
1035       
1036        @ldapmanager_connect
1037        def generic_teacher_to_itaca(self,uid,nif):
1038               
1039                teachers="ou=Teachers,ou=People," + self.llxvar("LDAP_BASE_DN")
1040                path="uid="+uid+","+teachers
1041                try:
1042                        mod_list=[]
1043                        mod=( ldap.MOD_REPLACE, "x-lliurex-usertype", "itaca" )
1044                        mod_list.append(mod)
1045                        mod=( ldap.MOD_ADD, "x-lliurex-nif",str(nif) )
1046                        mod_list.append(mod)
1047                        self.ldap.modify_s(path,mod_list)
1048                        return "true"
1049                       
1050                except Exception as e:
1051                        self.log("generic_teacher_to_itaca",e)
1052                        return e[0]["desc"]     
1053
1054               
1055        #def generic_student_to_itaca   
1056
1057       
1058        @ldapmanager_connect
1059        def add_generic_users(self,plantille,group_type,number,generic_name,pwd_generation_type,pwd=None):
1060               
1061                generated_users=[]
1062               
1063                for i in range(number):
1064                       
1065                        tmp_i=i+1
1066                       
1067                        val=str(tmp_i)
1068                       
1069                        if tmp_i < 10:
1070                                val="0"+str(tmp_i)
1071                       
1072                       
1073                        user_name=generic_name+ val
1074                       
1075                        generated_pwd=""
1076                       
1077                        if(pwd_generation_type==LdapManager.RANDOM_PASSWORDS):
1078                               
1079                               
1080                                generated_pwd="".join(random.sample(string.letters+string.digits, 4))
1081                                password=generated_pwd
1082                                ok=True
1083                               
1084                               
1085                               
1086                        if(pwd_generation_type==LdapManager.SAME_PASSWORD):
1087                                if(pwd!=None):
1088                                        password=pwd
1089                                        generated_pwd=password
1090                                else:
1091                                        #print "No password was given"
1092                                        break
1093                               
1094                        if(pwd_generation_type==LdapManager.PASS_EQUALS_USER):
1095                                password=user_name
1096                                generated_pwd=password
1097                       
1098                       
1099                        properties={}
1100                        properties["uid"]=user_name
1101                        properties["cn"]=user_name
1102                        properties["sn"]=user_name
1103                        properties["userPassword"]=password
1104                        properties["x-lliurex-usertype"]="generic"
1105                       
1106                        generated_dic=self.add_user(True,plantille,properties)
1107                       
1108                       
1109                        if type(generated_dic)==str:
1110                               
1111                                dic={}
1112                                dic["ERROR"]=user_name + ":" + generated_dic
1113                                generated_users.append(dic)
1114                               
1115                        else:
1116                       
1117                               
1118                       
1119                                if pwd_generation_type==LdapManager.PASS_EQUALS_USER:
1120                                        user_path=generated_dic["path"]
1121                                        generated_dic["userPassword"]=generated_dic["uid"]
1122                                        self.change_password(user_path,generated_dic["userPassword"])
1123                                        generated_pwd=generated_dic["userPassword"]
1124                                else:
1125                                        generated_dic["userPassword"]=generated_pwd
1126                               
1127                               
1128                               
1129                                if generated_dic!=None:
1130                                        if group_type!=None:
1131                                                self.add_to_group_type(group_type,generated_dic["uid"])
1132                                                generated_dic["groups"].append(group_type)
1133                                                                       
1134                                        generated_users.append(generated_dic)
1135                       
1136                       
1137                return generated_users
1138                       
1139                       
1140                       
1141               
1142               
1143        #def add_generic_users
1144
1145
1146        @ldapmanager_connect
1147        def add_to_generic_groups(self,plantille,user):
1148               
1149                teachers="cn=teachers,ou=Profiles,ou=Groups," + self.llxvar("LDAP_BASE_DN")
1150                students="cn=students,ou=Profiles,ou=Groups," + self.llxvar("LDAP_BASE_DN")
1151                others="cn=others,ou=Profiles,ou=Groups," + self.llxvar("LDAP_BASE_DN")
1152                user_path="uid="+user.uid+",ou="+plantille+",ou=People," + self.llxvar("LDAP_BASE_DN")
1153                teachers_groups=["dialout","cdrom","floppy","audio","dip","video","plugdev","netdev","vboxusers","fuse","epoptes"]
1154                students_groups=["dialout","cdrom","floppy","audio","dip","video","plugdev","netdev","vboxusers","fuse"]
1155               
1156                if(plantille=="Teachers"):
1157                       
1158                        mod_list=[]
1159                        mod2=(ldap.MOD_ADD,'memberUid',user.uid)
1160                        mod_list.append(mod2)
1161                        try:
1162                                self.ldap.modify_s(teachers,mod_list)
1163                                for group in teachers_groups:
1164                                        mod=(ldap.MOD_ADD,"memberUid",user.uid)
1165                                        mod_list=[]
1166                                        mod_list.append(mod)
1167                                        group_path="cn=" + group +",ou=System,ou=Groups," + self.llxvar("LDAP_BASE_DN")
1168                                        self.ldap.modify_s(group_path,mod_list)
1169                                       
1170                                teachers_groups.append("teachers")
1171                                return teachers_groups
1172                               
1173                        except Exception as e:
1174                                self.log("add_to_generic_groups",e,"Teachers")
1175                                print(e)
1176                                return None
1177                       
1178                       
1179               
1180                if(plantille=="Students"):
1181
1182                        #mod=(ldap.MOD_ADD,'member',user_path)
1183                        mod_list=[]
1184                        #mod_list.append(mod)
1185                        mod2=(ldap.MOD_ADD,'memberUid',user.uid)
1186                        mod_list.append(mod2)
1187
1188                        try:
1189                                self.ldap.modify_s(students,mod_list)
1190                               
1191                                for group in students_groups:
1192                                        mod=(ldap.MOD_ADD,"memberUid",user.uid)
1193                                        mod_list=[]
1194                                        mod_list.append(mod)
1195                                        group_path="cn=" + group +",ou=System,ou=Groups," + self.llxvar("LDAP_BASE_DN")
1196                                        self.ldap.modify_s(group_path,mod_list)
1197                               
1198                                students_groups.append("students")
1199                                return students_groups
1200                               
1201                               
1202                        except Exception as e:
1203                                self.log("add_to_generic_groups",e,"Students")
1204                                print(e)
1205                                return None
1206                       
1207                if(plantille=="Other"):
1208
1209                        mod=(ldap.MOD_ADD,'member',user_path)
1210                        mod_list=[]
1211                        mod_list.append(mod)
1212                       
1213                        try:
1214                               
1215                                self.ldap.modify_s(others,mod_list)
1216                                for group in students_groups:
1217                                        mod=(ldap.MOD_ADD,"memberUid",user.uid)
1218                                        mod_list=[]
1219                                        mod_list.append(mod)
1220                                        group_path="cn=" + group +",ou=System,ou=Groups," + self.llxvar("LDAP_BASE_DN")
1221                                        self.ldap.modify_s(group_path,mod_list)
1222                                       
1223                                students_groups.append("others")
1224                                return students_groups
1225                                       
1226                        except Exception as e:
1227                                self.log("add_to_generic_groups",e,"Others")
1228                                print(e)
1229                                return None
1230               
1231               
1232        #def add_to_generic_groups
1233       
1234       
1235        @ldapmanager_connect
1236        def add_to_group_type(self,cn,uid):
1237               
1238                path="cn=" + cn + ",ou=Managed,ou=Groups," + self.llxvar("LDAP_BASE_DN")
1239               
1240               
1241                mod=(ldap.MOD_ADD,'memberUid',uid)
1242                mod_list=[]
1243                mod_list.append(mod)
1244                       
1245                print("*** ADDING " + uid + " to " + path)
1246                try:
1247                        self.ldap.modify_s(path,mod_list)
1248                        return "true"
1249                except Exception as e:
1250                        self.log("add_to_group_type",e,"Teachers")
1251                        return e[0]["desc"]
1252               
1253               
1254               
1255        #def add_to_group_type
1256       
1257       
1258        @ldapmanager_connect
1259        def add_teacher_to_admins(self,uid):
1260               
1261                path="cn=admins,ou=Profiles,ou=Groups," + self.llxvar("LDAP_BASE_DN")
1262               
1263                user_dn="uid="+uid+",ou=Teachers,ou=People," + self.llxvar("LDAP_BASE_DN")
1264               
1265                mod_list=[]
1266                mod=(ldap.MOD_ADD,"memberUid",uid)
1267                mod_list.append(mod)
1268               
1269                #print "*** ADDING " + uid + " to admins"
1270                try:
1271                        self.ldap.modify_s(path,mod_list)
1272                        return "true"
1273                except Exception as e:
1274                        if type(e)==ldap.TYPE_OR_VALUE_EXISTS:
1275                                return "true"
1276                        else:
1277                                self.log("add_teacher_to_admins",e,uid)
1278                                return e[0]["desc"]
1279               
1280               
1281        #def add_teacher_to_admins
1282       
1283       
1284        @ldapmanager_connect
1285        def del_teacher_from_admins(self,uid):
1286
1287                path="cn=admins,ou=Profiles,ou=Groups," + self.llxvar("LDAP_BASE_DN")
1288               
1289                user_dn="uid="+uid+",ou=Teachers,ou=People," + self.llxvar("LDAP_BASE_DN")
1290               
1291               
1292                mod_list=[]
1293                mod=(ldap.MOD_DELETE,"memberUid",uid)
1294                mod_list.append(mod)
1295               
1296                #print "*** DELETING " + uid + " from admins"
1297                try:
1298                        self.ldap.modify_s(path,mod_list)
1299                        return "true"
1300                except Exception as e:
1301                       
1302                        if type(e)==ldap.NO_SUCH_ATTRIBUTE:
1303                                return "true"
1304                        else:
1305                                self.log("del_teacher_from_admins",e,uid)
1306                                return e[0]["desc"]
1307
1308
1309               
1310        #def del_teacher_from_admins
1311       
1312        @ldapmanager_connect
1313        def custom_search(self,basedn,filter="objectClass=*",attrl=None):
1314               
1315                try:
1316                       
1317                        result=self.ldap.search_s(basedn,ldap.SCOPE_SUBTREE,filter,attrl)
1318                       
1319                        return {"status":True,"msg":result}
1320                       
1321                       
1322                except Exception as e:
1323                       
1324                        return {"status":False,"msg":"Captured exception: %s"%e}
1325               
1326        #def custom_search
1327       
1328       
1329        @ldapmanager_connect
1330        def full_search(self,uid):
1331               
1332                ret={}
1333               
1334                result=self.ldap.search_s("ou=People,"+self.llxvar("LDAP_BASE_DN"),ldap.SCOPE_SUBTREE,"uid="+uid)
1335                #ret_list.append(result)
1336                user_list=[]
1337                for item in result:
1338                        path,info=item
1339                        d={}
1340                        d[path]={}
1341                        try:
1342                                for key in ["uid","uidNumber","gidNumber","sambaSID","objectClass","loginShell","homeDirectory","sambaAcctFlags"]:
1343                                        try:
1344                                                if key!="objectClass":
1345                                                        d[path][key]=info[key][0]
1346                                                else:
1347                                                        d[path][key]=info[key]
1348                                        except Exception as e:
1349                                                if "exception" not in d[path]:
1350                                                        d[path]["exception"]=[]
1351                                                d[path]["exception"].append(str(e))
1352                                       
1353                                user_list.append(d)
1354                        except:
1355                                continue
1356                               
1357                ret["users"]=user_list
1358               
1359                path="cn=admins,ou=Profiles,ou=Groups," + self.llxvar("LDAP_BASE_DN")
1360                result=self.ldap.search_s(path,ldap.SCOPE_SUBTREE)
1361               
1362                admin_list=[]
1363                #print result
1364                for item in result:
1365                        path,info=item
1366                        d={}
1367                        d[path]={}                     
1368                        for key in ["sambaGroupType","cn","sambaSID","gidNumber","description","objectClass","memberUid"]:
1369                                try:
1370                                        if key!="objectClass" and key!="memberUid":
1371                                                d[path][key]=info[key][0]
1372                                        else:
1373                                                d[path][key]=info[key]
1374                                       
1375                                except Exception as e:
1376                                        print path,e
1377                                        if "exception" not in d[path]:
1378                                                d[path]["exception"]=[]
1379                                        d[path]["exception"].append(str(e))
1380                               
1381                        admin_list.append(d)
1382                       
1383                ret["admins"]=admin_list
1384               
1385                path="ou=Managed,ou=Groups,"+self.llxvar("LDAP_BASE_DN")
1386                result=self.ldap.search_s(path,ldap.SCOPE_SUBTREE)
1387                group_list=[]
1388               
1389                for item in result:
1390                        path,info=item
1391                       
1392                        d={}
1393                        d[path]={}
1394                        d[path]["objectClass"]=info["objectClass"]
1395                        if "ou" in info:
1396                               
1397                                try:
1398                                        d[path]["ou"]=info["ou"][0]
1399                                        d[path]["x-lliurex-xid-counter"]=info["x-lliurex-xid-counter"][0]
1400                                except Exception as e:
1401                                        d[path]["exception"]=[]
1402                                        d[path]["exception"].append(str(e))
1403                        else:
1404                                for key in ["sambaGroupType","cn","x-lliurex-grouptype","sambaSID","gidNumber","description","memberUid","objectClass"]:
1405                                        try:
1406                                                if key!="memberUid" and key!="ObjectClass":
1407                                                        d[path][key]=info[key][0]
1408                                                else:
1409                                                        d[path][key]=info[key]
1410                                               
1411                                               
1412                                        except Exception as e:
1413                                                if "exception" not in d[path]:
1414                                                        d[path]["exception"]=[]
1415                                                d[path]["exception"].append(str(e))
1416                                       
1417                        group_list.append(d)
1418               
1419               
1420                ret["groups"]=group_list
1421               
1422                #ret_list.append(group_result)
1423               
1424                return ret
1425               
1426               
1427               
1428               
1429               
1430        #def search_user_native
1431       
1432        @ldapmanager_connect
1433        def search_user(self,uid):
1434                #ou=Students,ou=People
1435                result=self.ldap.search_s("ou=People,"+self.llxvar("LDAP_BASE_DN"),ldap.SCOPE_SUBTREE,"uid="+uid)
1436                user_list=[]
1437               
1438                path="cn=admins,ou=Profiles,ou=Groups," + self.llxvar("LDAP_BASE_DN")
1439                ret=self.ldap.search_s(path,ldap.SCOPE_SUBTREE)
1440                admins_list=ret[0][1]["memberUid"]
1441               
1442                path="ou=Managed,ou=Groups,"+self.llxvar("LDAP_BASE_DN")
1443                group_result=self.ldap.search_s(path,ldap.SCOPE_SUBTREE)
1444               
1445
1446                for item in result:
1447                        path,properties_dic=item
1448                       
1449                        group_list=[]
1450                       
1451                        for group in group_result:
1452                                g_path,dic=group
1453                                if "memberUid" in dic:
1454                                        if properties_dic["uid"][0] in dic["memberUid"]:
1455                                                tmp=g_path.split(",")
1456                                                cn=tmp[0].split("=")[1]
1457                                                group_list.append(cn)                   
1458               
1459                       
1460                        prop={}
1461                        try:
1462                                prop["uid"]=properties_dic["uid"][0]
1463                                prop["cn"]=properties_dic["cn"][0]
1464                                prop["sn"]=properties_dic["sn"][0]
1465                        except Exception as ex:
1466                                continue
1467                        user=LdapUser(prop)
1468                       
1469                        if path.find("Student")!=-1:
1470                                user.properties["profile"]="students"
1471                        if path.find("Teacher")!=-1:
1472                                user.properties["profile"]="teachers"
1473                        if path.find("Other")!=-1:
1474                                user.properties["profile"]="others"
1475                        if path.find("Admin")!=-1:
1476                                user.properties["profile"]="admin"
1477                       
1478                        user.properties["uidNumber"]=properties_dic["uidNumber"][0]
1479                        user.properties["gidNumber"]=properties_dic["gidNumber"][0]
1480                        user.properties["path"]=path
1481                        user.properties["groups"]=group_list
1482                       
1483                        if properties_dic.has_key("x-lliurex-usertype"):
1484                                user.properties["x-lliurex-usertype"]=properties_dic["x-lliurex-usertype"][0]
1485                               
1486                        if properties_dic.has_key("x-lliurex-nia"):
1487                                user.properties["x-lliurex-nia"]=properties_dic["x-lliurex-nia"][0]
1488                               
1489                        if properties_dic.has_key("x-lliurex-nif"):
1490                                user.properties["x-lliurex-nif"]=properties_dic["x-lliurex-nif"][0]
1491                       
1492                        if user.properties["uid"] in admins_list:
1493                                user.properties["is_admin"]=True
1494                        else:
1495                                user.properties["is_admin"]=False
1496                       
1497                        user_list.append(user)
1498                         
1499                       
1500                return user_list               
1501               
1502        #def search_user
1503       
1504       
1505        @ldapmanager_connect
1506        def light_search(self):
1507                result=self.ldap.search_s("ou=People,"+self.llxvar("LDAP_BASE_DN"),ldap.SCOPE_SUBTREE,"uid=*")
1508               
1509                user_list=[]
1510               
1511               
1512               
1513                for item in result:
1514                       
1515
1516                        path,properties_dic=item
1517                        desc=""
1518                        if "description" in properties_dic:
1519                                desc=properties_dic["description"][0]
1520                               
1521                       
1522                       
1523                        profile=""
1524                       
1525                        if path.find("Student")!=-1:
1526                                profile="students"
1527                        if path.find("Teacher")!=-1:
1528                                profile="teachers"
1529                        if path.find("Other")!=-1:
1530                                profile="others"
1531                        if path.find("Admin")!=-1:
1532                                profile="admin"                 
1533                       
1534                        #user_list.append((properties_dic["uid"][0],path,properties_dic["cn"][0],properties_dic["sn"][0],desc))
1535                        user_list.append((path,properties_dic["uid"][0],properties_dic["uidNumber"][0],properties_dic["cn"][0],properties_dic["sn"][0],profile))
1536                       
1537                       
1538                return user_list                       
1539               
1540        #def light_search
1541       
1542       
1543        @ldapmanager_connect
1544        def search_user_with_filter(self,filter):
1545                listldapusers=self.ldap.search_s("ou=People,"+self.llxvar("LDAP_BASE_DN"),ldap.SCOPE_SUBTREE,filter)
1546                result = {}
1547                for x in listldapusers:
1548                        #print x[0]
1549                        upgradeuser = {}
1550                        if x[0].find("Student")!=-1:
1551                                upgradeuser["profile"]="students"
1552                        elif x[0].find("Teachers")!=-1:
1553                                upgradeuser["profile"]="teachers"
1554                        elif x[0].find("Admin")!=-1:
1555                                upgradeuser["profile"]="admins"
1556                       
1557                        for key,value in x[1].items():
1558                                if len(value) == 1:
1559                                        upgradeuser[key] = value[0]
1560                                else:
1561                                        upgradeuser[key] = value
1562                        #upgradeuser['profile'] = x[1]['profile'][0]
1563                       
1564                               
1565                        result[upgradeuser['uid']] = upgradeuser
1566                return result
1567       
1568       
1569        @ldapmanager_connect
1570        def search_user_dic(self,uid):
1571                #ou=Students,ou=People
1572                result=self.ldap.search_s("ou=People,"+self.llxvar("LDAP_BASE_DN"),ldap.SCOPE_SUBTREE,"uid="+uid)
1573               
1574                user_list=[]
1575               
1576                for item in result:
1577                        path,properties_dic=item
1578                        prop={}
1579                        prop["uid"]=properties_dic["uid"][0]
1580                        prop["cn"]=properties_dic["cn"][0]
1581                        prop["sn"]=properties_dic["sn"][0]
1582                        user=LdapUser(prop)
1583                        user.properties["path"]=path
1584                        user_list.append(user.properties)
1585                         
1586                       
1587                return user_list               
1588       
1589       
1590        @ldapmanager_connect
1591        def search_students(self,uid):
1592                #ou=Students,ou=People
1593                result=self.ldap.search_s("ou=Students,ou=People,"+self.llxvar("LDAP_BASE_DN"),ldap.SCOPE_SUBTREE,"uid="+uid)
1594               
1595                user_list=[]
1596               
1597                for item in result:
1598                        path,properties_dic=item
1599                        prop={}
1600                        prop["uid"]=properties_dic["uid"][0]
1601                        prop["cn"]=properties_dic["cn"][0]
1602                        prop["sn"]=properties_dic["sn"][0]                     
1603                        user=LdapUser(prop)
1604                        user.properties["path"]=path
1605                        user_list.append(user)
1606                       
1607
1608                return user_list               
1609               
1610        #def search_user
1611
1612       
1613        @ldapmanager_connect
1614        def search_teachers(self,uid):
1615                #ou=Students,ou=People
1616                result=self.ldap.search_s("ou=Teachers,ou=People,"+self.llxvar("LDAP_BASE_DN"),ldap.SCOPE_SUBTREE,"uid="+uid)
1617               
1618                user_list=[]
1619               
1620                for item in result:
1621                        path,properties_dic=item
1622                        prop={}
1623                        prop["uid"]=properties_dic["uid"][0]
1624                        prop["cn"]=properties_dic["cn"][0]
1625                        prop["sn"]=properties_dic["sn"][0]
1626                        user=LdapUser(prop)
1627                        user.properties["path"]=path
1628                        user_list.append(user)
1629                       
1630                return user_list               
1631               
1632        #def search_user               
1633       
1634       
1635        @ldapmanager_connect
1636        def delete_user(self,uid):
1637               
1638                user=self.search_user(uid)
1639                if user[0].properties["path"].find("Students")!=-1:
1640                       
1641                        try:
1642                                user[0].properties["groups"]=self.get_generic_groups(uid)
1643                                user[0].properties["groups"].append("students")
1644                                self.delete_student(uid)
1645                                return user[0].properties
1646                        except:
1647                                self.log("delete_user",e,"Student: " + uid)
1648                                return None
1649               
1650                if user[0].properties["path"].find("Teachers")!=-1:
1651                       
1652                        try:
1653                                user[0].properties["groups"]=self.get_generic_groups(uid)
1654                                user[0].properties["groups"].append("teachers")
1655                                self.delete_teacher(uid)
1656                                return user[0].properties
1657                        except:
1658                                self.log("delete_user",e,"Teacher: " + uid)
1659                                return None
1660               
1661               
1662        #def delete_user
1663       
1664        @ldapmanager_connect
1665        def delete_student(self,uid):
1666       
1667                try:
1668
1669                        group_list=self.get_groups(uid)
1670                        for group in group_list:
1671                                self.del_user_from_group(uid,group)
1672                               
1673                        path="uid="+uid+",ou=Students,ou=People,"+self.llxvar("LDAP_BASE_DN")   
1674                        group_list=self.get_generic_groups(uid)
1675                       
1676                        for group in group_list:
1677                                self.del_user_from_generic_group(uid,group)             
1678
1679                        self.del_student_from_student_group(uid)
1680                        self.ldap.delete_s(path)
1681                        return "true"
1682
1683                       
1684                except Exception as e:
1685                        self.log("delete_student",e,uid)
1686                        return e[0]['desc']
1687                       
1688       
1689        #def delete_user
1690       
1691        @ldapmanager_connect
1692        def delete_other(self,uid):
1693       
1694                try:
1695                        group_list=self.get_groups(uid)
1696
1697                        for group in group_list:
1698                                self.del_user_from_group(uid,group)
1699                               
1700                        path="uid="+uid+",ou=Other,ou=People,"+self.llxvar("LDAP_BASE_DN")     
1701                        group_list=self.get_generic_groups(uid)
1702                       
1703                        for group in group_list:
1704                                self.del_user_from_generic_group(uid,group)             
1705
1706                        self.del_student_from_student_group(uid)
1707                        self.ldap.delete_s(path)
1708                        return "true"
1709
1710                except Exception as e:
1711                        self.log("delete_other",e,uid)
1712                        return e[0]['desc']
1713                       
1714       
1715        #def delete_user
1716
1717       
1718       
1719       
1720        @ldapmanager_connect
1721        def delete_teacher(self,uid):
1722       
1723                try:
1724
1725                        group_list=self.get_groups(uid)
1726                        for group in group_list:
1727                                self.del_user_from_group(uid,group)
1728                               
1729                        path="uid="+uid+",ou=Teachers,ou=People,"+self.llxvar("LDAP_BASE_DN")   
1730                        group_list=self.get_generic_groups(uid)
1731
1732                        for group in group_list:
1733                                self.del_user_from_generic_group(uid,group)             
1734
1735                        self.del_teacher_from_teacher_group(uid)
1736                        self.ldap.delete_s(path)
1737                        return "true"
1738                       
1739                except Exception as e:
1740                        self.log("delete_teacher",e,uid)
1741                        return e[0]['desc']
1742                       
1743       
1744        #def delete_user
1745
1746       
1747        @ldapmanager_connect
1748        def get_groups(self,uid):
1749               
1750                path="ou=Managed,ou=Groups,"+self.llxvar("LDAP_BASE_DN")
1751                result=self.ldap.search_s(path,ldap.SCOPE_SUBTREE)
1752                group_list=[]
1753                for group in result:
1754                        g_path,dic=group
1755                        if "memberUid" in dic:
1756                                if uid in dic["memberUid"]:
1757                                        tmp=g_path.split(",")
1758                                        cn=tmp[0].split("=")[1]
1759                                        group_list.append(cn)
1760                                       
1761                return group_list                       
1762               
1763        #def get_groups
1764       
1765       
1766        @ldapmanager_connect
1767        def get_available_groups(self):
1768               
1769                path="ou=Managed,ou=Groups,"+self.llxvar("LDAP_BASE_DN")
1770                result=self.ldap.search_s(path,ldap.SCOPE_SUBTREE)
1771                group_list=[]
1772                for group in result:
1773                        g_path,dic=group
1774                        dic["path"]=g_path
1775                        if "posixGroup" in dic["objectClass"]:
1776                                group_list.append(dic)
1777                                       
1778                return group_list       
1779               
1780        #def get_available_groups
1781       
1782       
1783        @ldapmanager_connect
1784        def get_generic_groups(self,uid):
1785               
1786               
1787                path="ou=System,ou=Groups,"+self.llxvar("LDAP_BASE_DN")
1788                result=self.ldap.search_s(path,ldap.SCOPE_SUBTREE)
1789                group_list=[]
1790                for group in result:
1791                        g_path,dic=group
1792                        if "memberUid" in dic:
1793                               
1794                                if uid in dic["memberUid"]:
1795                                        tmp=g_path.split(",")
1796                                        cn=tmp[0].split("=")[1]
1797                                        group_list.append(cn)
1798                                       
1799                return group_list                       
1800               
1801        #def get_generic_groups
1802       
1803       
1804        @ldapmanager_connect
1805        def del_student_from_student_group(self,uid):
1806               
1807                path="cn=students,ou=Profiles,ou=Groups," + self.llxvar("LDAP_BASE_DN")
1808                user_dn="uid=" + uid + ",ou=Students,ou=People," + self.llxvar("LDAP_BASE_DN")
1809                #print user_dn
1810                mod_list=[]
1811                mod=(ldap.MOD_DELETE,"memberUid",uid)
1812                mod_list.append(mod)
1813                try:
1814                        self.ldap.modify_s(path,mod_list)
1815                except Exception as e:
1816                        self.log("del_student_from_student_group",e,uid)
1817                        return e[0]['desc']
1818               
1819        #def del_student_from_student_group
1820       
1821       
1822        @ldapmanager_connect
1823        def del_teacher_from_teacher_group(self,uid):
1824               
1825                path="cn=teachers,ou=Profiles,ou=Groups," + self.llxvar("LDAP_BASE_DN")
1826                user_dn="uid=" + uid + ",ou=Teachers,ou=People," + self.llxvar("LDAP_BASE_DN")
1827                #print user_dn
1828                mod_list=[]
1829                mod=(ldap.MOD_DELETE,"memberUid",uid)
1830                mod_list.append(mod)
1831                try:
1832                        self.ldap.modify_s(path,mod_list)
1833                except Exception as e:
1834                        self.log("del_teacher_from_teacher_group",e,uid)
1835                        return e[0]["desc"]
1836               
1837        #def del_student_from_student_group     
1838       
1839       
1840        @ldapmanager_connect
1841        def del_user_from_group(self,uid,group_cn):
1842               
1843                mod=(ldap.MOD_DELETE,"memberUid",uid)
1844                mod_list=[]
1845                mod_list.append(mod)
1846                path="cn="+group_cn+",ou=Managed,ou=Groups,"+self.llxvar("LDAP_BASE_DN")
1847                try:
1848                        self.ldap.modify_s(path,mod_list)
1849                        return "true"
1850                except Exception as e:
1851                        #print e
1852                        self.log("del_user_from_group",e,uid)
1853                        return e[0]["desc"]
1854               
1855        #def del_user_from_group
1856
1857        @ldapmanager_connect
1858        def del_user_from_generic_group(self,uid,group_cn):
1859               
1860                mod=(ldap.MOD_DELETE,"memberUid",uid)
1861                mod_list=[]
1862                mod_list.append(mod)
1863                path="cn="+group_cn+",ou=System,ou=Groups,"+self.llxvar("LDAP_BASE_DN")
1864                try:
1865                        self.ldap.modify_s(path,mod_list)
1866                except Exception as e:
1867                        self.log("del_user_from_generic_group",e,uid + " " + group_cn)
1868                        return e[0]["desc"]
1869                       
1870               
1871        #def del_user_from_group
1872
1873        @ldapmanager_connect
1874        def add_group(self,properties):
1875               
1876                path="cn="+str(properties["cn"])+",ou=Managed,ou=Groups," + self.llxvar("LDAP_BASE_DN")
1877               
1878                group=LdapGroup(properties)
1879               
1880                try:
1881                        gidNumber=self.set_next_xgid()[1]
1882                        group.attributes.append(("gidNumber",str(gidNumber)))
1883                        group.attributes.append(("sambaSID",self.samba_id+"-"+str(gidNumber)))
1884                        group.attributes.append(("sambaGroupType",str(2)))
1885                        self.ldap.add_s(path,group.attributes)
1886                        return "true"
1887                except Exception as e:
1888                        self.log("add_group",e)
1889                        print(e)
1890                        return e[0]["desc"]
1891               
1892        #def add_group
1893       
1894        @ldapmanager_connect
1895        def print_group_list(self,cn):
1896               
1897               
1898                a=self.ldap.search_s(self.llxvar("LDAP_BASE_DN"),ldap.SCOPE_SUBTREE,"cn="+cn)
1899                count=1
1900                for item in a:
1901                        count+=1
1902                        print(item)
1903                               
1904               
1905        #def print_list
1906       
1907       
1908        @ldapmanager_connect
1909        def search_group(self,cn):
1910               
1911                result=self.ldap.search_s("ou=Managed,ou=Groups,"+self.llxvar("LDAP_BASE_DN"),ldap.SCOPE_SUBTREE,"cn="+cn)
1912               
1913                group_list=[]
1914               
1915                for item in result:
1916                        path,properties_dic=item
1917                                               
1918                        prop={}
1919                        prop["cn"]=cn
1920                                                       
1921                        group=LdapGroup(prop)
1922                        group.properties["path"]=path
1923                        if "memberUid" in properties_dic:
1924                                group.properties["memberUid"]=properties_dic["memberUid"]
1925                               
1926                        group_list.append(group)
1927
1928                return group_list
1929               
1930        #def search_group
1931       
1932       
1933        @ldapmanager_connect
1934        def get_dn(self,uid):
1935               
1936                result=self.ldap.search_s("ou=People,"+self.llxvar("LDAP_BASE_DN"),ldap.SCOPE_SUBTREE,"uid="+uid)
1937               
1938                user_list=[]
1939               
1940                path="ou=Managed,ou=Groups,"+self.llxvar("LDAP_BASE_DN")
1941                group_result=self.ldap.search_s(path,ldap.SCOPE_SUBTREE)
1942               
1943               
1944                for item in result:
1945                        path,properties_dic=item
1946                        return path
1947               
1948        #def get_dn
1949
1950       
1951        @ldapmanager_connect
1952        def get_students_passwords(self):
1953               
1954                result=self.ldap.search_s("ou=Students,ou=People,"+self.llxvar("LDAP_BASE_DN"),ldap.SCOPE_SUBTREE,"uid=*")
1955                ret_list = []
1956               
1957                for item in result:
1958                       
1959                        try:
1960                                path,dic=item
1961                                user={}
1962                                if dic.has_key("userPassword"):
1963                                        user['passwd']=dic["userPassword"][0]
1964                                if dic.has_key("sambaNTPassword"):
1965                                        user['sambaNTPassword']=dic["sambaNTPassword"][0]
1966                                if dic.has_key("sambaLMPassword"):
1967                                        user['sambaLMPassword']=dic["sambaLMPassword"][0]
1968                                if dic.has_key("sn"):
1969                                        user['sn']=dic["sn"][0]
1970                                if dic.has_key("userPassword"):
1971                                        user['cn']=dic["cn"][0]
1972                                if dic.has_key("userPassword"):
1973                                        user['uid']=dic["uid"][0]
1974                                ret_list.append(user)
1975                        except Exception as e:
1976                                pass
1977                               
1978               
1979               
1980                return ret_list
1981               
1982        #def get_students_passwords
1983
1984
1985
1986        @ldapmanager_connect
1987        def get_teachers_passwords(self):
1988               
1989                result=self.ldap.search_s("ou=Teachers,ou=People,"+self.llxvar("LDAP_BASE_DN"),ldap.SCOPE_SUBTREE,"uid=*")
1990                ret_list = []
1991               
1992                for item in result:
1993                       
1994                        try:
1995                                path,dic=item
1996                                user={}
1997                                if dic.has_key("userPassword"):
1998                                        user['passwd']=dic["userPassword"][0]
1999                                if dic.has_key("sambaNTPassword"):
2000                                        user['sambaNTPassword']=dic["sambaNTPassword"][0]
2001                                if dic.has_key("sambaLMPassword"):
2002                                        user['sambaLMPassword']=dic["sambaLMPassword"][0]
2003                                if dic.has_key("sn"):
2004                                        user['sn']=dic["sn"][0]
2005                                if dic.has_key("userPassword"):
2006                                        user['cn']=dic["cn"][0]
2007                                if dic.has_key("userPassword"):
2008                                        user['uid']=dic["uid"][0]
2009                                ret_list.append(user)
2010                        except Exception as e:
2011                                pass
2012                               
2013               
2014               
2015                return ret_list
2016               
2017        #def get_students_passwords
2018
2019        @ldapmanager_connect
2020        def delete_group(self,cn):
2021               
2022                path="cn=" + cn + ",ou=Managed,ou=Groups," + self.llxvar("LDAP_BASE_DN")
2023                print("Deleting group " + path)
2024                try:
2025                        self.ldap.delete_s(path)
2026                        return "true"
2027                except Exception as e:
2028                        self.log("delete_group",e,cn)
2029                        return e[0]["desc"]
2030               
2031        #def delete_group
2032       
2033        '''
2034                uid_list : list
2035                no_group_user : Boolean
2036        '''
2037        @ldapmanager_connect
2038        def freeze_user(self,uid_list,no_group_user=True):
2039               
2040                frozen_users={}
2041               
2042                for uid in uid_list:
2043                        if uid!=None and len(uid)>0:
2044                                path="uid=" + uid + ",ou=Students,ou=People," + self.llxvar("LDAP_BASE_DN")
2045                                mod_list=[]
2046                                mod=( ldap.MOD_REPLACE, "x-lliurex-freeze", "True" )
2047                                mod_list.append(mod)
2048                                try:
2049                                        self.ldap.modify_s(path,mod_list)
2050                                        frozen_users[uid]=True
2051                                except Exception as e:
2052                                        self.log("modify_value",e)
2053                                        frozen_users[uid]=str(e)
2054                               
2055                return frozen_users
2056                       
2057        #def freeze_user
2058       
2059        @ldapmanager_connect
2060        def unfreeze_user(self,uid_list):
2061
2062                unfrozen_users={}
2063               
2064                for uid in uid_list:
2065                        if uid != None and len(uid) > 0 :
2066                                try:
2067                                        path="uid=" + uid + ",ou=Students,ou=People," + self.llxvar("LDAP_BASE_DN")
2068                                        mod_list=[]
2069                                        mod=(ldap.MOD_REPLACE,'x-lliurex-freeze',"False")
2070                                        mod_list.append(mod)
2071                                        self.ldap.modify_s(path,mod_list)
2072                                        unfrozen_users[uid]=True
2073                                except Exception as exc:
2074                                        self.log("unfreeze_user",e,"1")
2075                                        print(exc[0]['desc'])
2076                                        unfrozen_users[uid]=str(e)
2077
2078                return unfrozen_users
2079                                       
2080
2081        #def unfreeze_user
2082       
2083        @ldapmanager_connect
2084        def freeze_group(self,group_list):
2085               
2086                frozen_groups={}
2087               
2088                for cn in group_list:
2089                        try:
2090                                path="cn=" + cn + ",ou=Managed,ou=Groups," + self.llxvar("LDAP_BASE_DN")
2091                                mod_list=[]
2092                                mod=(ldap.MOD_REPLACE,'x-lliurex-freeze',"True")
2093                                mod_list.append(mod)
2094                                self.ldap.modify_s(path,mod_list)
2095                                frozen_groups[cn]=True
2096                        except Exception as e:
2097                                print(e)
2098                                frozen_groups[cn]=str(e)
2099                               
2100                return frozen_groups
2101                               
2102        #def freeze_group
2103       
2104        @ldapmanager_connect
2105        def unfreeze_group(self,group_list):
2106
2107                unfrozen_groups={}
2108               
2109                for cn in group_list:
2110                        try:
2111                                path="cn=" + cn + ",ou=Managed,ou=Groups," + self.llxvar("LDAP_BASE_DN")
2112                                mod_list=[]
2113                                mod=(ldap.MOD_REPLACE,'x-lliurex-freeze',"False")
2114                                mod_list.append(mod)
2115                                self.ldap.modify_s(path,mod_list)
2116                                unfrozen_groups[cn]=True
2117                        except Exception as e:
2118                                print(e)
2119                                unfrozen_groups[cn]=str(e)
2120                               
2121                return unfrozen_groups
2122               
2123        #def unfreeze_group
2124       
2125        @ldapmanager_connect
2126        def is_frozen_user(self,uid):
2127
2128                try:
2129                       
2130                        users = self.ldap.search_s("ou=People,"+self.llxvar("LDAP_BASE_DN"),ldap.SCOPE_SUBTREE,"(uid=%s)"%uid)
2131                        for x,y in users:
2132                               
2133                               
2134                                if y.has_key("x-lliurex-freeze"):
2135                                        if y["x-lliurex-freeze"][0]=="True":
2136                                                return True
2137                               
2138                        group_list=self.get_groups(uid)
2139                       
2140                        frozen_groups=self.get_frozen_groups()
2141                       
2142                        for group in group_list:
2143                                if group in frozen_groups:
2144                                        return True
2145                                       
2146                        return False
2147                       
2148                except:
2149                       
2150                        return False
2151                                       
2152        # def is_freeze_user
2153       
2154       
2155        @ldapmanager_connect
2156        def get_frozen_users(self):
2157               
2158                path="ou=Students,ou=People," + self.llxvar("LDAP_BASE_DN")
2159                users=self.ldap.search_s(path,ldap.SCOPE_SUBTREE)
2160                lst=[]
2161                for x,y in users:
2162                        if y.has_key("x-lliurex-freeze"):
2163                                if y["x-lliurex-freeze"][0]=="True":
2164                                        lst.append(y["uid"][0])
2165                                       
2166                return lst
2167               
2168               
2169        #def get_frozen_users
2170       
2171       
2172        @ldapmanager_connect
2173        def get_frozen_groups(self):
2174               
2175                path="ou=Managed,ou=Groups," + self.llxvar("LDAP_BASE_DN")
2176                groups=self.ldap.search_s(path,ldap.SCOPE_SUBTREE)
2177                lst=[]
2178                for x,y in groups:
2179                        if y.has_key("x-lliurex-freeze"):
2180                                if y["x-lliurex-freeze"][0]=="True":
2181                                        lst.append(y["cn"][0])
2182                                       
2183                return lst
2184               
2185        #def get_frozen_groups
2186       
2187       
2188#class LdapManager
2189
2190if __name__=="__main__":
2191       
2192       
2193       
2194        ldapman=LdapManager(getLliurexVariables())
2195       
2196        #ldapman.get_samba_id2()
2197       
2198        #ldapman.print_list()
2199       
2200        #add_generic_users(self,plantille,group_type,number,generic_name,pwd_generation_type,pwd=None)
2201        #RANDOM_PASSWORDS
2202        #SAME_PASSWORD
2203        #PASS_EQUALS_USER
2204        #print ldapman.add_generic_users("Students",None,1,"kha",ldapman.PASS_EQUALS_USER)
2205
2206
2207        properties={}
2208        properties['uid']='pepa2'
2209        properties['cn']='pepa'
2210        properties['userPassword']="lliurex"
2211        #properties['displayName']='pepito'
2212        properties['sn']='palotes'
2213       
2214
2215        #print ldapman.add_user(True,"Students",properties)
2216
2217        #print ldapman.add_teacher_to_admins("micomi")
2218
2219        #ldapman.del_teacher_from_admins("profe01")
2220
2221
2222        #print ldapman.generate_uid("ana de iratxe","garcia de las torres")
2223        '''
2224        list=ldapman.search_user("*")
2225       
2226        for item in list:
2227                print item.properties["uid"]
2228
2229        print ""
2230        '''
2231       
2232       
2233       
2234       
2235       
2236       
2237       
2238       
2239       
2240       
2241       
2242       
2243       
2244       
Note: See TracBrowser for help on using the repository browser.