3 files changed, 366 insertions, 0 deletions
diff --git a/lib/functions.c b/lib/functions.c
new file mode 100644
index 00000000..44f21b55
--- /dev/null
+++ b/lib/functions.c
@@ -0,0 +1,270 @@
+/* vi: set sw=4 ts=4 :*/
+/* functions.c - reusable stuff.
+ *
+ * Functions with the x prefix are wrappers for library functions.  They either
+ * succeed or kill the program with an error message, but never return failure.
+ * They usually have the same arguments and return value as the function they
+ * wrap.
+ *
+ * Copyright 2006 Rob Landley <rob@landley.net>
+ */
+
+#include "toys.h"
+
+void verror_msg(char *msg, int err, va_list va)
+{
+	fprintf(stderr, "%s: ", toys.which->name);
+	vfprintf(stderr, msg, va);
+	if (err) fprintf(stderr, ": %s", strerror(err));
+	putc('\n', stderr);
+}
+
+void error_msg(char *msg, ...)
+{
+	va_list va;
+
+	va_start(va, msg);
+	verror_msg(msg, 0, va);
+	va_end(va);
+}
+
+void perror_msg(char *msg, ...)
+{
+	va_list va;
+
+	va_start(va, msg);
+	verror_msg(msg, errno, va);
+	va_end(va);
+}
+
+// Die with an error message.
+void error_exit(char *msg, ...)
+{
+	va_list va;
+
+	va_start(va, msg);
+	verror_msg(msg, 0, va);
+	va_end(va);
+
+	exit(toys.exitval);
+}
+
+// Die with an error message and strerror(errno)
+void perror_exit(char *msg, ...)
+{
+	va_list va;
+
+	va_start(va, msg);
+	verror_msg(msg, errno, va);
+	va_end(va);
+
+	exit(toys.exitval);
+}
+
+// Like strncpy but always null terminated.
+void strlcpy(char *dest, char *src, size_t size)
+{
+	strncpy(dest,src,size);
+	dest[size-1] = 0;
+}
+
+// Die unless we can allocate memory.
+void *xmalloc(size_t size)
+{
+	void *ret = malloc(size);
+	if (!ret) error_exit("xmalloc");
+
+	return ret;
+}
+
+// Die unless we can allocate prezeroed memory.
+void *xzalloc(size_t size)
+{
+	void *ret = xmalloc(size);
+	bzero(ret,size);
+	return ret;
+}
+
+// Die unless we can change the size of an existing allocation, possibly
+// moving it.  (Notice different arguments from libc function.)
+void xrealloc(void **ptr, size_t size)
+{
+	*ptr = realloc(*ptr, size);
+	if (!*ptr) error_exit("xrealloc");
+}
+
+// Die unless we can allocate a copy of this string.
+void *xstrndup(char *s, size_t n)
+{
+	void *ret = xmalloc(++n);
+	strlcpy(ret, s, n);
+	
+	return ret;
+}
+
+// Die unless we can allocate enough space to sprintf() into.
+char *xmsprintf(char *format, ...)
+{
+	va_list va;
+	int len;
+	char *ret;
+	
+	// How long is it?
+
+	va_start(va, format);
+	len = vsnprintf(0, 0, format, va);
+	len++;
+	va_end(va);
+
+	// Allocate and do the sprintf()
+	ret = xmalloc(len);
+	va_start(va, format);
+	vsnprintf(ret, len, format, va);	
+	va_end(va);
+
+	return ret;
+}
+
+// Die unless we can exec argv[] (or run builtin command).  Note that anything
+// with a path isn't a builtin, so /bin/sh won't match the builtin sh.
+void xexec(char **argv)
+{
+	toy_exec(argv);
+	execvp(argv[0], argv);
+	error_exit("No %s", argv[0]);
+}
+
+// Die unless we can open/create a file, returning file descriptor.
+int xopen(char *path, int flags, int mode)
+{
+	int fd = open(path, flags, mode);
+	if (fd == -1) error_exit("No file %s\n", path);
+	return fd;
+}
+
+// Die unless we can open/create a file, returning FILE *.
+FILE *xfopen(char *path, char *mode)
+{
+	FILE *f = fopen(path, mode);
+	if (!f) error_exit("No file %s\n", path);
+	return f;
+}
+
+// Read from file handle, retrying if interrupted.
+ssize_t reread(int fd, void *buf, size_t count)
+{
+	ssize_t len;
+	for (;;) {
+		len = read(fd, buf, count);
+		if (len >= 0  || errno != EINTR) return len;
+	}
+}
+
+// Keep reading until full or EOF
+ssize_t readall(int fd, void *buf, size_t count)
+{
+	size_t len = 0;
+	while (len<count) {
+		int i = reread(fd, buf, count);
+		if (!i) return len;
+		if (i<0) return i;
+		count += i;
+	}
+
+	return count;
+}
+
+// Die if we can't fill a buffer
+void xread(int fd, char *buf, size_t count)
+{
+	if (count != readall(fd, buf, count)) perror_exit("xread");
+}	
+
+char *xgetcwd(void)
+{
+	char *buf = getcwd(NULL, 0);
+	if (!buf) error_exit("xgetcwd");
+
+	return buf;
+}
+
+// Find this file in a colon-separated path.
+
+char *find_in_path(char *path, char *filename)
+{
+	char *next, *res = NULL, *cwd = xgetcwd();
+
+	while ((next = index(path,':'))) {
+		int len = next-path;
+
+		if (len==1) res = xmsprintf("%s/%s", cwd, filename);
+		else res = xmsprintf("%*s/%s",len-1,path,filename);
+		// Is there a file here we can execute?
+		if (!access(res, X_OK)) {
+			struct stat st;
+			// Confirm it's not a directory.
+			if (!stat(res, &st) && S_ISREG(st.st_mode)) break;
+		}
+		free(res);
+		res = NULL;
+	}
+	free(cwd);
+
+	return res;
+}
+
+// Convert unsigned int to ascii, writing into supplied buffer.  A truncated
+// result contains the first few digits of the result ala strncpy, and is
+// always null terminated (unless buflen is 0).
+void utoa_to_buf(unsigned n, char *buf, unsigned buflen)
+{
+	int i, out = 0;
+
+	if (buflen) {
+		for (i=1000000000; i; i/=10) {
+			int res = n/i;
+
+			if ((res || out || i == 1) && --buflen>0) {
+				out++;
+				n -= res*i;
+				*buf++ = '0' + res;
+			}
+		}
+		*buf = 0;
+	}
+}
+
+// Convert signed integer to ascii, using utoa_to_buf()
+void itoa_to_buf(int n, char *buf, unsigned buflen)
+{
+	if (buflen && n<0) {
+		n = -n;
+		*buf++ = '-';
+		buflen--;
+	}
+	utoa_to_buf((unsigned)n, buf, buflen);
+}
+
+// This static buffer is used by both utoa() and itoa(), calling either one a
+// second time will overwrite the previous results.
+//
+// The longest 32 bit integer is -2 billion plus a null terminator: 12 bytes.
+// Note that int is always 32 bits on any remotely unix-like system, see
+// http://www.unix.org/whitepapers/64bit.html for details.
+
+static char itoa_buf[12];
+
+// Convert unsigned integer to ascii, returning a static buffer.
+char *utoa(unsigned n)
+{
+	utoa_to_buf(n, itoa_buf, sizeof(itoa_buf));
+
+	return itoa_buf;
+}
+
+char *itoa(int n)
+{
+	itoa_to_buf(n, itoa_buf, sizeof(itoa_buf));
+
+	return itoa_buf;
+}
diff --git a/lib/getmountlist.c b/lib/getmountlist.c
new file mode 100644
index 00000000..8410a923
--- /dev/null
+++ b/lib/getmountlist.c
@@ -0,0 +1,45 @@
+/* vi: set sw=4 ts=4 : */
+/* getmountlist.c - Get a linked list of mount points, with stat information.
+ *
+ * Copyright 2006 Rob Landley <rob@landley.net>
+ */
+
+#include "toys.h"
+
+#include <mntent.h>
+
+char *path_mounts = "/proc/mounts";
+
+// Get a list of mount points from /etc/mtab or /proc/mounts, including
+// statvfs() information.  This returns a reversed list, which is good for
+// finding overmounts and such.
+
+struct mtab_list *getmountlist(int die)
+{
+	FILE *fp;
+	struct mtab_list *mtlist, *mt;
+	struct mntent me;
+	char evilbuf[2*PATH_MAX];
+
+	mtlist = 0;
+	if (!(fp = setmntent(path_mounts, "r"))) {
+		if (die) error_exit("cannot open %s", path_mounts);
+	} else {
+		while (getmntent_r(fp, &me, evilbuf, sizeof(evilbuf))) {
+			mt = xzalloc(sizeof(struct mtab_list) + strlen(me.mnt_fsname) +
+				strlen(me.mnt_dir) + strlen(me.mnt_type) + 3);
+			mt->next = mtlist;
+			// Get information about this filesystem.  Yes, we need both.
+			stat(me.mnt_dir, &(mt->stat));
+			statvfs(me.mnt_dir, &(mt->statvfs));
+			// Remember information from /proc/mounts
+			strcpy(mt->type, me.mnt_type);
+			mt->dir = mt->type + strlen(mt->type) + 1;
+			strcpy(mt->dir, me.mnt_dir);
+			mt->device = mt->dir + strlen(mt->dir) + 1;
+			strcpy(mt->device, me.mnt_fsname);
+			mtlist = mt;
+		}
+	}
+	return mtlist;
+}
diff --git a/lib/lib.h b/lib/lib.h
new file mode 100644
index 00000000..28888a49
--- /dev/null
+++ b/lib/lib.h
@@ -0,0 +1,51 @@
+/* vi: set ts=4 :*/
+/* lib.h - header file for lib directory
+ *
+ * Copyright 2006 Rob Landley <rob@landley.net>
+ */
+
+// functions.c
+void verror_msg(char *msg, int err, va_list va);
+void error_msg(char *msg, ...);
+void perror_msg(char *msg, ...);
+void error_exit(char *msg, ...);
+void perror_exit(char *msg, ...);
+void strlcpy(char *dest, char *src, size_t size);
+void *xmalloc(size_t size);
+void *xzalloc(size_t size);
+void xrealloc(void **ptr, size_t size);
+void *xstrndup(char *s, size_t n);
+char *xmsprintf(char *format, ...);
+void xexec(char **argv);
+int xopen(char *path, int flags, int mode);
+FILE *xfopen(char *path, char *mode);
+ssize_t reread(int fd, void *buf, size_t count);
+ssize_t readall(int fd, void *buf, size_t count);
+void xread(int fd, char *buf, size_t count);
+char *xgetcwd(void);
+char *find_in_path(char *path, char *filename);
+void utoa_to_buf(unsigned n, char *buf, unsigned buflen);
+void itoa_to_buf(int n, char *buf, unsigned buflen);
+char *utoa(unsigned n);
+char *itoa(int n);
+
+// llist.c
+void llist_free(void *list, void (*freeit)(void *data));
+
+struct string_list {
+	struct string_list *next;
+	char *str;
+};
+
+// getmountlist.c
+struct mtab_list {
+	struct mtab_list *next;
+	struct stat stat;
+	struct statvfs statvfs;
+	char *dir;
+	char *device;
+	char type[0];
+};
+
+struct mtab_list *getmountlist(int die);
+