← Back to branch summary

~azzar1/unity/add-show-desktop-key

« back to all changes in this revision

Viewing changes to lib/common/makeuser.py

  • Committer: drtomc
  • Date: 2008-03-04 01:17:10 UTC
  • Revision ID: svn-v3-trunk0:2b9c9e99-6f39-0410-b283-7f802c844ae2:trunk:636
remakeuser: use the database, not the password file.

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/common/makeuser.py
31
31
 
32
32
# TODO: When creating a new home directory, chown it to its owner
33
33
 
34
 
# TODO: In chown_to_webserver:
35
 
# Do not call os.system("chown www-data") - use Python lib
36
 
# and use the web server uid given in conf. (Several places).
37
 
 
38
34
import md5
39
35
import os
40
36
import stat
42
38
import time
43
39
import uuid
44
40
import warnings
45
 
import filecmp
46
 
import logging
 
41
 
47
42
import conf
48
43
import db
49
44
 
50
 
def chown_to_webserver(filename):
51
 
    """
52
 
    Chowns a file so the web server user owns it.
53
 
    (This is useful in setting up Subversion conf files).
54
 
    Assumes root.
55
 
    """
56
 
    try:
57
 
        os.system("chown -R www-data:www-data %s" % filename)
58
 
    except:
59
 
        pass
60
 
 
61
45
def make_svn_repo(login, throw_on_error=True):
62
46
    """Create a repository for the given user.
63
47
    """
70
54
        print repr(exc)
71
55
        if throw_on_error:
72
56
            raise
73
 
 
74
 
    chown_to_webserver(path)
 
57
    try:
 
58
        os.system("chown -R www-data:www-data %s" % path)
 
59
    except Exception:
 
60
        pass
75
61
 
76
62
def rebuild_svn_config():
77
63
    """Build the complete SVN configuration file.
102
88
        f.write("\n")
103
89
    f.close()
104
90
    os.rename(conf.svn_conf + ".new", conf.svn_conf)
105
 
    chown_to_webserver(conf.svn_conf)
106
91
 
107
92
def make_svn_config(login, throw_on_error=True):
108
93
    """Add an entry to the apache-svn config file for the given user.
116
101
    #f.write("@admin = rw\n")
117
102
    f.write("\n")
118
103
    f.close()
119
 
    chown_to_webserver(conf.svn_conf)
120
104
 
121
105
def make_svn_auth(login, throw_on_error=True):
122
106
    """Setup svn authentication for the given user.
136
120
    if res != 0 and throw_on_error:
137
121
        raise Exception("Unable to create ivle-auth for %s" % login)
138
122
 
139
 
    # Make sure the file is owned by the web server
140
 
    if create == "c":
141
 
        chown_to_webserver(conf.svn_auth_ivle)
142
 
 
143
123
    return passwd
144
124
 
145
 
def generate_manifest(basedir, targetdir, parent=''):
146
 
    """ From a basedir and a targetdir work out which files are missing or out 
147
 
    of date and need to be added/updated and which files are redundant and need 
148
 
    to be removed.
149
 
    
150
 
    parent: This is used for the recursive call to track the relative paths 
151
 
    that we have decended.
152
 
    """
153
 
    
154
 
    cmp = filecmp.dircmp(basedir, targetdir)
155
 
 
156
 
    # Add all new files and files that have changed
157
 
    to_add = [os.path.join(parent,x) for x in (cmp.left_only + cmp.diff_files)]
158
 
 
159
 
    # Remove files that are redundant
160
 
    to_remove = [os.path.join(parent,x) for x in cmp.right_only]
161
 
    
162
 
    # Recurse
163
 
    for d in cmp.common_dirs:
164
 
        newbasedir = os.path.join(basedir, d)
165
 
        newtargetdir = os.path.join(targetdir, d)
166
 
        newparent = os.path.join(parent, d)
167
 
        (sadd,sremove) = generate_manifest(newbasedir, newtargetdir, newparent)
168
 
        to_add += sadd
169
 
        to_remove += sremove
170
 
 
171
 
    return (to_add, to_remove)
172
 
 
173
 
 
174
 
def make_jail(username, uid, force=True, svn_pass=None):
 
125
def make_jail(username, uid, force=True):
175
126
    """Creates a new user's jail space, in the jail directory as configured in
176
127
    conf.py.
177
128
 
178
 
    This only creates things within /home - everything else is expected to be
179
 
    part of another UnionFS branch.
 
129
    This expects there to be a "template" directory within the jail root which
 
130
    contains all the files for a sample student jail. It creates the student's
 
131
    directory in the jail root, by making a hard-link copy of every file in the
 
132
    template directory, recursively.
180
133
 
181
134
    Returns the path to the user's home directory.
182
135
 
189
142
 
190
143
    force: If false, exception if jail already exists for this user.
191
144
    If true (default), overwrites it, but preserves home directory.
192
 
 
193
 
    svn_pass: If provided this will be a string, the randomly-generated
194
 
    Subversion password for this user (if you happen to already have it).
195
 
    If not provided, it will be read from the database.
196
145
    """
197
146
    # MUST run as root or some of this may fail
198
147
    if os.getuid() != 0:
199
148
        raise Exception("Must run make_jail as root")
200
149
    
 
150
    templatedir = os.path.join(conf.jail_base, 'template')
 
151
    if not os.path.isdir(templatedir):
 
152
        raise Exception("Template jail directory does not exist: " +
 
153
            templatedir)
201
154
    # tempdir is for putting backup homes in
202
 
    tempdir = os.path.join(conf.jail_base, '__temp__')
 
155
    tempdir = os.path.join(conf.jail_base, 'temp')
203
156
    if not os.path.exists(tempdir):
204
157
        os.makedirs(tempdir)
205
158
    elif not os.path.isdir(tempdir):
206
159
        os.unlink(tempdir)
207
160
        os.mkdir(tempdir)
208
 
    userdir = os.path.join(conf.jail_src_base, username)
 
161
    userdir = os.path.join(conf.jail_base, username)
209
162
    homedir = os.path.join(userdir, 'home')
210
 
    userhomedir = os.path.join(homedir, username)   # Return value
211
163
 
212
164
    if os.path.exists(userdir):
213
165
        if not force:
214
166
            raise Exception("User's jail already exists")
215
167
        # User jail already exists. Blow it away but preserve their home
216
 
        # directory. It should be all that is there anyway, but you never
217
 
        # know!
 
168
        # directory.
218
169
        # Ignore warnings about the use of tmpnam
219
170
        warnings.simplefilter('ignore')
220
171
        homebackup = os.tempnam(tempdir)
223
174
        # into a directory if it already exists, just fails. Therefore it is
224
175
        # not susceptible to tmpnam symlink attack.
225
176
        shutil.move(homedir, homebackup)
226
 
        shutil.rmtree(userdir)
227
 
        os.makedirs(homedir)
228
 
        shutil.move(homebackup, homedir)
 
177
        try:
 
178
            # Any errors that occur after making the backup will be caught and
 
179
            # the backup will be un-made.
 
180
            # XXX This will still leave the user's jail in an unusable state,
 
181
            # but at least they won't lose their files.
 
182
            shutil.rmtree(userdir)
 
183
 
 
184
            # Hard-link (copy aliasing) the entire tree over
 
185
            linktree(templatedir, userdir)
 
186
        finally:
 
187
            # Set up the user's home directory (restore backup)
 
188
            # First make sure the directory is empty and its parent exists
 
189
            try:
 
190
                shutil.rmtree(homedir)
 
191
            except:
 
192
                pass
 
193
            # XXX If this fails the user's directory will be lost (in the temp
 
194
            # directory). But it shouldn't fail as homedir should not exist.
 
195
            os.makedirs(homedir)
 
196
            shutil.move(homebackup, homedir)
 
197
        return os.path.join(homedir, username)
229
198
    else:
230
199
        # No user jail exists
 
200
        # Hard-link (copy aliasing) the entire tree over
 
201
        linktree(templatedir, userdir)
 
202
 
231
203
        # Set up the user's home directory
232
 
        os.makedirs(userhomedir)
 
204
        userhomedir = os.path.join(homedir, username)
 
205
        os.mkdir(userhomedir)
233
206
        # Chown (and set the GID to the same as the UID).
234
207
        os.chown(userhomedir, uid, uid)
235
208
        # Chmod to rwxr-xr-x (755)
236
209
        os.chmod(userhomedir, 0755)
237
 
 
238
 
    # There are 2 special files which need to be generated specific to this
239
 
    # user: /opt/ivle/lib/conf/conf.py and /etc/passwd.
240
 
    # "__" username "__" users are exempt (special)
241
 
    if not (username.startswith("__") and username.endswith("__")):
242
 
        make_conf_py(username, userdir, conf.jail_system, svn_pass)
243
 
        make_etc_passwd(username, userdir, conf.jail_system, uid)
244
 
 
245
 
    return userhomedir
246
 
 
247
 
def make_conf_py(username, user_jail_dir, staging_dir, svn_pass=None):
248
 
    """
249
 
    Creates (overwriting any existing file, and creating directories) a
250
 
    file /opt/ivle/lib/conf/conf.py in a given user's jail.
251
 
    username: Username.
252
 
    user_jail_dir: User's jail dir, ie. conf.jail_base + username
253
 
    staging_dir: The dir with the staging copy of the jail. (With the
254
 
        template conf.py file).
255
 
    svn_pass: As with make_jail. User's SVN password, but if not supplied,
256
 
        will look up in the DB.
257
 
    """
258
 
    template_conf_path = os.path.join(staging_dir,"opt/ivle/lib/conf/conf.py")
259
 
    conf_path = os.path.join(user_jail_dir, "opt/ivle/lib/conf/conf.py")
260
 
    os.makedirs(os.path.dirname(conf_path))
261
 
 
262
 
    # If svn_pass isn't supplied, grab it from the DB
263
 
    if svn_pass is None:
264
 
        dbconn = db.DB()
265
 
        svn_pass = dbconn.get_user(username).svn_pass
266
 
        dbconn.close()
267
 
 
268
 
    # Read the contents of the template conf file
269
 
    try:
270
 
        template_conf_file = open(template_conf_path, "r")
271
 
        template_conf_data = template_conf_file.read()
272
 
        template_conf_file.close()
273
 
    except:
274
 
        # Couldn't open template conf.py for some reason
275
 
        # Just treat it as empty file
276
 
        template_conf_data = ("# Warning: Problem building config script.\n"
277
 
                              "# Could not find template conf.py file.\n")
278
 
 
279
 
    conf_file = open(conf_path, "w")
280
 
    conf_file.write(template_conf_data)
281
 
    conf_file.write("\n# The login name for the owner of the jail\n")
282
 
    conf_file.write("login = %s\n" % repr(username))
283
 
    conf_file.write("\n")
284
 
    conf_file.write("# The subversion-only password for the owner of "
285
 
        "the jail\n")
286
 
    conf_file.write("svn_pass = %s\n" % repr(svn_pass))
287
 
    conf_file.close()
288
 
 
289
 
    # Make this file world-readable
290
 
    # (chmod 644 conf_path)
291
 
    os.chmod(conf_path, stat.S_IRUSR | stat.S_IWUSR | stat.S_IRGRP
292
 
                        | stat.S_IROTH)
293
 
 
294
 
def make_etc_passwd(username, user_jail_dir, template_dir, unixid):
295
 
    """
296
 
    Creates /etc/passwd in the given user's jail. This will be identical to
297
 
    that in the template jail, except for the added entry for this user.
298
 
    """
299
 
    template_passwd_path = os.path.join(template_dir, "etc/passwd")
300
 
    passwd_path = os.path.join(user_jail_dir, "etc/passwd")
301
 
    passwd_dir = os.path.dirname(passwd_path)
302
 
    if not os.path.exists(passwd_dir):
303
 
        os.makedirs(passwd_dir)
304
 
    shutil.copy(template_passwd_path, passwd_path)
305
 
    passwd_file = open(passwd_path, 'a')
306
 
    passwd_file.write('%s:x:%d:%d::/home/%s:/bin/bash'
307
 
                      % (username, unixid, unixid, username))
308
 
    passwd_file.close()
 
210
        return userhomedir
309
211
 
310
212
def linktree(src, dst):
311
213
    """Recursively hard-link a directory tree using os.link().
371
273
        if res != 0 and throw_on_error:
372
274
            raise Exception("Unable to create local-auth for %s" % kwargs['login'])
373
275
 
374
 
    # Make sure the file is owned by the web server
375
 
    if create == "c":
376
 
        chown_to_webserver(conf.svn_auth_local)
377
 
 
378
 
def mount_jail(login):
379
 
    # This is where we'll mount to...
380
 
    destdir = os.path.join(conf.jail_base, login)
381
 
    # ... and this is where we'll get the user bits.
382
 
    srcdir = os.path.join(conf.jail_src_base, login)
383
 
    try:
384
 
        if not os.path.exists(destdir):
385
 
            os.mkdir(destdir)
386
 
        if os.system('/bin/mount -t aufs -o dirs=%s:%s=ro none %s'
387
 
                     % (srcdir, conf.jail_system, destdir)) == 0:
388
 
            logging.info("mounted user %s's jail." % login)
389
 
        else:
390
 
            logging.error("failed to mount user %s's jail!" % login)
391
 
    except Exception, message:
392
 
        logging.warning(str(message))