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

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

adding retries in case samba id is not ready to be queried

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