- add home directory on request and populate it (/etc/skel)

1 files changed, 433 insertions, 4 deletions

diff --git a/USER/USER.xs b/USER/USER.xs
index 50e32fb..d1ef6c9 100644
--- a/USER/USER.xs
+++ b/USER/USER.xs
@@ -11,12 +11,33 @@
 
 #include <grp.h>
 #include <pwd.h>
+#include <crypt.h>
+#include <ctype.h>
+#include <dirent.h>
+#include <fcntl.h>
+#include <locale.h>
+#include <limits.h>
+#include <sys/signal.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <sys/time.h>
+#include <stdio.h>
 #include <stdlib.h>
+#include <string.h>
 #include <unistd.h>
 #include <glib.h>
+#include <utime.h>
 #include <libuser/user.h>
 #include <libuser/user_private.h>
 
+#define INVALID (-0x80000000)
+#ifndef _
+#define _(String) gettext(String)
+#endif
+#ifndef N_
+#define N_(String) (String)
+#endif
+
 typedef struct context USER__ADMIN;
 typedef struct lu_ent USER__ENT;
 typedef struct lu_error USER__ERR;
@@ -40,6 +61,395 @@ static SV ** convert_value_array_list(register SV **sp, GValueArray *array) {
 	return sp;
 }
 
+/* Populate a user's home directory, copying data from a named skeleton
+ * directory, setting all ownerships as given, and setting the mode of
+ * the top-level directory as given. */
+int
+lu_homedir_populate(const char *skeleton, const char *directory,
+		    uid_t owner, gid_t group, mode_t mode,
+		    USER__ERR **error)
+{
+	struct dirent *ent;
+	DIR *dir;
+	struct stat st;
+	char skelpath[PATH_MAX], path[PATH_MAX], buf[PATH_MAX];
+	struct utimbuf timebuf;
+	int ifd = -1, ofd = -1, i;
+	off_t offset;
+	LU_ERROR_CHECK(error);
+	/* If the destination directory exists, return. */
+	dir = opendir(skeleton);
+	if (dir == NULL) {
+		lu_error_new(error, lu_error_generic,
+			     _("Error reading `%s': %s"), skeleton,
+			     strerror(errno));
+		return 0;
+	}
+	/* Create the top-level directory. */
+	if ((mkdir(directory, mode) == -1) && (errno != EEXIST)) {
+		lu_error_new(error, lu_error_generic,
+			     _("Error creating `%s': %s"), directory,
+			     strerror(errno));
+		closedir(dir);
+		return 0;
+	}
+	/* Set the ownership on the top-level directory. */
+	chown(directory, owner, group);
+	while ((ent = readdir(dir)) != NULL) {
+		/* Iterate through each item in the directory. */
+		/* Skip over self and parent hard links. */
+		if (strcmp(ent->d_name, ".") == 0) {
+			continue;
+		}
+		if (strcmp(ent->d_name, "..") == 0) {
+			continue;
+		}
+		/* Build the path of the skeleton file or directory and
+		 * its corresponding member in the new tree. */
+		snprintf(skelpath, sizeof(skelpath), "%s/%s",
+			 skeleton, ent->d_name);
+		snprintf(path, sizeof(path), "%s/%s", directory,
+			 ent->d_name);
+		/* What we do next depends on the type of entry we're
+		 * looking at. */
+		if (lstat(skelpath, &st) != -1) {
+			/* We always want to preserve atime/mtime. */
+			timebuf.actime = st.st_atime;
+			timebuf.modtime = st.st_mtime;
+                        /* If it's a directory, descend into it. */
+			if (S_ISDIR(st.st_mode)) {
+				if (!lu_homedir_populate(skelpath,
+							 path,
+							 owner,
+							 st.st_gid ?: group,
+							 st.st_mode,
+							 error)) {
+					/* Aargh!  Fail up. */
+					closedir(dir);
+					return 0;
+				}
+				/* Set the date on the directory. */
+				utime(path, &timebuf);
+				continue;
+			}
+                        /* If it's a symlink, duplicate it. */
+			if (S_ISLNK(st.st_mode)) {
+				if (readlink(skelpath, buf,
+					     sizeof(buf) - 1) != -1) {
+					buf[sizeof(buf) - 1] = '\0';
+					symlink(buf, path);
+					lchown(path, owner, st.st_gid ?: group);
+					utime(path, &timebuf);
+				}
+				continue;
+			}
+			/* If it's a regular file, copy it. */
+			if (S_ISREG(st.st_mode)) {
+				/* Open both the input and output
+				 * files.  If we fail to do either,
+				 * we have to give up. */
+				ifd = open(skelpath, O_RDONLY);
+				if (ifd != -1) {
+					ofd = open(path,
+						   O_EXCL | O_CREAT | O_WRONLY,
+						   st.st_mode);
+				}
+				if ((ifd == -1) || (ofd == -1)) {
+					/* Sorry, no can do. */
+					close (ifd);
+					close (ofd);
+					continue;
+				}
+                                /* Now just copy the data. */
+				do {
+					i = read(ifd, &buf, sizeof(buf));
+					if (i > 0) {
+						write(ofd, buf, i);
+					}
+				} while (i > 0);
+                                /* Close the files. */
+				offset = lseek(ofd, 0, SEEK_CUR);
+				if (offset != ((off_t) -1)) {
+					ftruncate(ofd, offset);
+				}
+				close (ifd);
+				close (ofd);
+				/* Set the ownership and timestamp on
+				 * the new file. */
+				chown(path, owner, st.st_gid ?: group);
+				utime(path, &timebuf);
+				continue;
+			}
+			/* Note that we don't copy device specials. */
+		}
+	}
+	closedir(dir);
+        return 1;
+}
+
+/* Recursively remove a user's home (or really, any) directory. */
+int
+lu_homedir_remove(const char *directory, struct lu_error ** error)
+{
+	struct dirent *ent;
+	DIR *dir;
+	struct stat st;
+	char path[PATH_MAX];
+	LU_ERROR_CHECK(error);
+	/* Open the directory.  This catches the case that it's already gone. */
+	dir = opendir(directory);
+	if (dir == NULL) {
+		lu_error_new(error, lu_error_generic,
+			     _("Error removing `%s': %s"), directory,
+			     strerror(errno));
+		return 0;
+	}
+	/* Iterate over all of its contents. */
+	while ((ent = readdir(dir)) != NULL) {
+		/* Skip over the self and parent hard links. */
+		if (strcmp(ent->d_name, ".") == 0) {
+			continue;
+		}
+		if (strcmp(ent->d_name, "..") == 0) {
+			continue;
+		}
+		/* Generate the full path of the next victim. */
+		snprintf(path, sizeof(path), "%s/%s", directory, ent->d_name);
+		/* What we do next depends on whether or not the next item to
+		 * remove is a directory. */
+		if (lstat(path, &st) != -1) {
+			if (S_ISDIR(st.st_mode)) {
+				/* We decend into subdirectories... */
+				if (lu_homedir_remove(path, error) == FALSE) {
+					closedir(dir);
+					return 0;
+				}
+			} else {
+				/* ... and unlink everything else. */
+				if (unlink(path) == -1) {
+					lu_error_new(error,
+						     lu_error_generic,
+						     _("Error removing "
+						     "`%s': %s"),
+						     path,
+						     strerror
+						     (errno));
+					closedir(dir);
+					return 0;
+				}
+			}
+		}
+	}
+	closedir(dir);
+
+	/* As a final step, remove the directory itself. */
+	if (rmdir(directory) == -1) {
+		lu_error_new(error, lu_error_generic,
+			     _("Error removing `%s': %s"), directory,
+			     strerror(errno));
+		return 0;
+	}
+
+	return TRUE;
+}
+/* Move a directory from one place to another. */
+int
+lu_homedir_move(const char *oldhome, const char *newhome,
+		USER__ERR ** error)
+{
+	struct stat st;
+	LU_ERROR_CHECK(error);
+	/* If the directory exists... */
+	if (stat(oldhome, &st) != -1) {
+		/* ... and we can copy it ... */
+		if (lu_homedir_populate(oldhome, newhome,
+					st.st_uid, st.st_gid, st.st_mode,
+					error)) {
+			/* ... remove the old one. */
+			return lu_homedir_remove(oldhome, error);
+		}
+	}
+	return 0;
+}
+/* Concatenate a string onto another string on the heap. */
+char *
+lu_strconcat(char *existing, const char *appendee)
+{
+	char *tmp;
+	if (existing == NULL) {
+		existing = g_strdup(appendee);
+	} else {
+		tmp = g_strconcat(existing, appendee, NULL);
+		g_free(existing);
+		existing = tmp;
+	}
+	return existing;
+}
+/* Send nscd an arbitrary signal. */
+void
+lu_signal_nscd(int signum)
+{
+	FILE *fp;
+	char buf[LINE_MAX];
+	/* If it's running, then its PID is in this file.  Open it. */
+	if ((fp = fopen("/var/run/nscd.pid", "r")) != NULL) {
+		/* Read the PID. */
+		memset(buf, 0, sizeof(buf));
+		fgets(buf, sizeof(buf), fp);
+		/* If the PID is sane, send it a signal. */
+		if (strlen(buf) > 0) {
+			pid_t pid = atol(buf);
+			if (pid != 0) {
+				kill(pid, signum);
+			}
+		}
+		fclose(fp);
+	}
+}
+
+/* Send nscd a SIGHUP. */
+void
+lu_hup_nscd()
+{
+	lu_signal_nscd(SIGHUP);
+}
+
+/* Create a mail spool for the user. */
+int
+lu_mailspool_create_remove(USER__ADMIN *ctx, USER__ENT *ent,
+			   int action)
+{
+	GValueArray *array;
+	GValue *value;
+	const char *spooldir;
+	long uid, gid;
+	char *p, *username;
+	struct group grp, *err;
+	USER__ENT *groupEnt;
+	USER__ERR *error = NULL;
+	char buf[LINE_MAX * 4];
+	int fd;
+
+	/* Find the GID of the owner of the file. */
+	gid = INVALID;
+	groupEnt = lu_ent_new();
+	if (lu_group_lookup_name(ctx, "mail", groupEnt, &error)) {
+		array = lu_ent_get(groupEnt, LU_GIDNUMBER);
+		if (array != NULL) {
+			value = g_value_array_get_nth(array, 0);
+			if (G_VALUE_HOLDS_LONG(value)) {
+				gid = g_value_get_long(value);
+			} else
+			if (G_VALUE_HOLDS_STRING(value)) {
+				gid = strtol(g_value_get_string(value), &p, 0);
+				if (*p != '\0') {
+					gid = INVALID;
+				}
+			} else {
+				g_assert_not_reached();
+			}
+		}
+	}
+	lu_ent_free(groupEnt);
+
+	/* Er, okay.  Check with libc. */
+	if (gid == INVALID) {
+		if ((getgrnam_r("mail", &grp, buf, sizeof(buf), &err) == 0) &&
+		    (err == &grp)) {
+			gid = grp.gr_gid;
+		}
+	}
+
+	/* Aiieee.  Use the user's group. */
+	if (gid == INVALID) {
+		array = lu_ent_get(ent, LU_GIDNUMBER);
+		if (array != NULL) {
+			value = g_value_array_get_nth(array, 0);
+			if (G_VALUE_HOLDS_LONG(value)) {
+				gid = g_value_get_long(value);
+			} else
+			if (G_VALUE_HOLDS_STRING(value)) {
+				gid = strtol(g_value_get_string(value), &p, 0);
+				if (*p == '\0') {
+					gid = INVALID;
+				}
+			} else {
+				g_warning("Unable to determine user's GID.");
+				g_assert_not_reached();
+			}
+		}
+	}
+	g_return_val_if_fail(gid != INVALID, FALSE);
+
+	/* Now get the user's UID. */
+	array = lu_ent_get(ent, LU_UIDNUMBER);
+	if (array != NULL) {
+		value = g_value_array_get_nth(array, 0);
+		uid = INVALID;
+		if (G_VALUE_HOLDS_LONG(value)) {
+			uid = g_value_get_long(value);
+		} else
+		if (G_VALUE_HOLDS_STRING(value)) {
+			uid = strtol(g_value_get_string(value), &p, 0);
+			if (*p != '\0') {
+				uid = INVALID;
+			}
+		} else {
+			g_warning("Unable to determine user's UID.");
+			g_assert_not_reached();
+		}
+	}
+	g_return_val_if_fail(uid != INVALID, FALSE);
+
+	/* Now get the user's login. */
+	username = NULL;
+	array = lu_ent_get(ent, LU_USERNAME);
+	if (array != NULL) {
+		value = g_value_array_get_nth(array, 0);
+		if (G_VALUE_HOLDS_LONG(value)) {
+			username = g_strdup_printf("%ld",
+						   g_value_get_long(value));
+		} else
+		if (G_VALUE_HOLDS_STRING(value)) {
+			username = g_value_dup_string(value);
+		} else {
+			g_warning("Unable to determine user's name.");
+			g_assert_not_reached();
+		}
+	}
+	g_return_val_if_fail(username != NULL, FALSE);
+
+	/* Get the location of the spool directory. */
+	spooldir = lu_cfg_read_single(ctx, "defaults/mailspooldir",
+				      "/var/mail");
+
+	/* That wasn't that hard.  Now we just need to create the file. */
+	p = g_strdup_printf("%s/%s", spooldir, username);
+	g_free(username);
+	if (action) {
+		fd = open(p, O_WRONLY | O_CREAT, 0);
+		if (fd != -1) {
+			fchown(fd, uid, gid);
+			fchmod(fd, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP);
+			close(fd);
+			g_free(p);
+			return 1;
+		}
+	} else {
+		if (unlink(p) == 0) {
+			g_free(p);
+			return 1;
+		}
+		if (errno == ENOENT) {
+			g_free(p);
+			return 1;
+		}
+	}
+	g_free(p);
+
+	return 0;
+}
+
 MODULE = USER       PACKAGE = USER::ADMIN         PREFIX = Admin_
 
 USER::ADMIN *
@@ -112,13 +522,13 @@ Admin_UserAdd(self, ent, is_system, dont_create_home)
                 
                 if (lu_homedir_populate(skeleton, homeDirectory,
                                         uidNumber, gidNumber, 0700,
-                                        &error) == FALSE) {
+                                        &error) == 0) {
                         warn("Error creating %s: %s.\n", homeDirectory, error ? error->string : "unknown error");
                         RETVAL = 2;
                 }
 
                 /* Create a mail spool for the user. */
-                if (lu_mailspool_create_remove(self, ent, TRUE) != TRUE) {
+                if (lu_mailspool_create_remove(self, ent, TRUE) != 1) {
                         warn(_("Error creating mail spool.\n"));
                         return 8;
                 }
@@ -148,6 +558,19 @@ Admin_InitUser(self, name, is_system)
         XPUSHs(sv_2mortal(sv_bless(newRV_noinc(newSViv(ent)), gv_stashpv("USER::ENT", 1))));
 
 void
+Admin_UserSetPass(self, ent, userPasswd)
+        USER::ADMIN *self
+        USER::ENT *ent
+        char *userPasswd
+        PPCODE:
+        USER__ERR *error = NULL;
+        gboolean crypted = FALSE;
+	if (lu_user_setpass(self, ent, userPasswd, crypted, &error) == FALSE) {
+                croak("Failed to set password %s.\n", error ? error->string : _("unknown error"));
+                if (error) { lu_error_free(&error); }
+        }
+
+void
 Admin_LookupUserByName(self, name)
         USER::ADMIN *self
         char *name
@@ -204,9 +627,15 @@ Admin_LookupGroupById(self, id)
         }
 
 void 
-Admin_GroupAdd(self, name)
+Admin_GroupAdd(self, ent)
         USER::ADMIN *self
-        char *name
+        USER::ENT *ent
+        PPCODE:
+        struct lu_error *error = NULL;
+        GValue value;
+        if (lu_group_add(self, ent, &error) == FALSE) {
+                warn("Group creation failed.\n");
+        }
 
 void
 Admin_GroupDel(self, ent)