fiss-minit

minit-update.c (5298B)

---

 #include "minit.h"
 
 #include <dirent.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/file.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <unistd.h>
 
 #define USAGE  "Usage: minit-update [ -v [ -u ] ]\n"
 #define BUFLEN 1500
 
 /*
  increases file size by almost 4k
 #define WITH_STRERROR */
 
 static struct process* root;
 
 static int infd, outfd;
 static int maxprocess = -1;
 static int processalloc;
 
 static char buf[BUFLEN + 1];
 
 static unsigned int verbose;
 static int          do_update;
 
 void feed_struct_to_minit(struct process* data);
 
 ssize_t read_outfd(void* buf, size_t count);
 
 void addprocess(struct process* p);
 
 
 void die(const char* msg) {
 	fputs(msg, stderr);
 	_exit(111);
 }
 
 
 // void buffer_putsnlflush(buffer* b, const char* msg) {
 // 	fputs(msg, b);
 // 	buffer_putflush(b, "\n", 1);
 // }
 
 
 #ifdef WITH_STRERROR
 void buffer_puts_strerror(const char* msg) {
 	fputs("minit-update: ", stderr);
 	fputs(msg, stderr);
 	buffer_putsnlflush(stderr, strerror(errno));
 }
 #else
 #	define buffer_puts_strerror(a) fputs(a, stderr)
 #endif
 
 
 void* xmalloc(size_t size) {
 	void* ptr = malloc(size);
 	if (!ptr) die("malloc() failed\n");
 	return ptr;
 }
 
 
 void copywrite(const char* service) {
 	strncpy(buf + 1, service, BUFLEN);
 	buf[BUFLEN] = 0;
 	write(infd, buf, strlen(buf));
 }
 
 
 int read_reply_from_minit(void) {
 	if (read_outfd(buf, BUFLEN) == 1) {
 		if (buf[0] == '1') return 1;
 		if (buf[0] == '0') fputs("expected '1' from minit, got '0' - minit too old?\n", stderr);
 	}
 	/* XXX: Uuuh. Should this be checked?
 	 else fputs("minit response not understood\n", stderr);
 	*/
 	return 0;
 }
 
 
 void find_service(int subdir, char* name, char* parent) {
 	struct stat    statbuf;
 	char*          service   = 0;
 	DIR*           dirstream = 0;
 	struct dirent* dir;
 
 	if (chdir(name)) return;
 
 	if (parent) {
 		service = xmalloc(strlen(parent) + strlen(name) + 2);
 		strcpy(service, parent);
 		strcat(service, "/");
 		strcat(service, name);
 	} else {
 		if (subdir) {
 			service = xmalloc(strlen(name) + 1);
 			strcpy(service, name);
 		}
 	}
 #if 0 
  buffer_putsnlflush(stdout,service);
 #endif
 
 	if (service) { /* request and read a "struct process" from minit */
 		struct process tmp;
 
 		if (verbose) {
 			fputs("minit-update: status for ", stdout);
 			fputs(service, stdout);
 		}
 
 		buf[0] = 'D';
 		copywrite(service);
 
 		switch (read_outfd(&tmp, sizeof(tmp))) {
 			case sizeof(tmp):
 				tmp.name = strdup(service);
 				addprocess(&tmp);
 				if (verbose) fputs(" saved.\n", stdout);
 				break;
 			case 1:
 				if (verbose) fputs(" failed - minit has no information on this service\n", stdout);
 #if 0  
     break;
    default:
      fputs(" failed - read incomplete structure!\n", stdout);
 #endif
 		}
 	}
 
 	dirstream = opendir(".");
 	if (!dirstream) goto ret;
 
 	while ((dir = readdir(dirstream))) {
 		if (dir->d_name[0] != '.') {
 			if (!lstat(dir->d_name, &statbuf)) {
 				if (S_ISDIR(statbuf.st_mode)) {
 					find_service(1, dir->d_name, service);
 #if 0   
         } else {
            buffer_putsnlflush(stdout,dir->d_name);
 #endif
 				}
 			} else {
 				fputs(dir->d_name, stderr);
 				fputs(": cannot stat\n", stderr);
 				fprintf(stderr, "lstat() failed: %s\n", strerror(errno));
 			}
 		}
 	} /* while */
 
 	closedir(dirstream);
 
 ret:
 	if (service) free(service);
 	chdir(MINITROOT);
 	if (parent) chdir(parent);
 }
 
 
 int main(int argc, char** argv) {
 	int i;
 
 	if (argc < 2) die(USAGE);
 
 	while (argc > 1) {
 		argc--;
 		if (argv[argc][0] == '-') {
 			switch (argv[argc][1]) {
 				case 'v':
 					verbose++;
 					break;
 				case 'u':
 					do_update = 1;
 					break;
 				default:
 					fputs("minit-update: Unknown Option: ", stderr);
 					fprintf(stderr, "%s\n", argv[argc]);
 			}
 		} else
 			die(USAGE);
 	}
 
 	infd  = open(MINITROOT "/in", O_WRONLY);
 	outfd = open(MINITROOT "/out", O_RDONLY);
 
 	if (infd < 0 || outfd < 0) die("could not open " MINITROOT "/in or " MINITROOT "/out\n");
 
 	while (lockf(infd, F_TLOCK, 1)) {
 		fprintf(stderr, "could not acquire lock: %s\n", strerror(errno));
 		sleep(1);
 	}
 
 	find_service(0, MINITROOT, 0);
 
 	if (maxprocess == -1)
 		die("Could not extract running services from minit\n");
 
 	if (verbose) fputs("minit-update: telling minit to execve itself\n", stdout);
 
 	if (!do_update) {
 		fputs("Test mode: No update done.\n", stderr);
 		return 0;
 	}
 
 	write(infd, "update", 6);
 	sleep(1);
 
 	for (i = 0; i <= maxprocess; i++) {
 		if (verbose) {
 			fputs("minit-update: restoring status for ", stdout);
 			printf("%s\n", root[i].name);
 		}
 
 		buf[0] = 'U';
 		copywrite(root[i].name);
 
 		read_reply_from_minit();
 
 		write(infd, &root[i], sizeof(struct process));
 
 		if (read_reply_from_minit() && verbose) {
 			fputs("minit-update: restored service ", stdout);
 			printf("%s\n", root[i].name);
 		}
 
 	} /* for() */
 
 	return 0;
 }
 
 
 ssize_t read_outfd(void* buf, size_t count) {
 	ssize_t br = read(outfd, buf, count);
 
 	if (br < 0) buffer_puts_strerror("Error reading from outfd: ");
 	return br;
 }
 
 
 void addprocess(struct process* p) {
 	if (maxprocess + 1 >= processalloc) {
 		struct process* fump;
 		processalloc += 8;
 		if ((fump = (struct process*) realloc(root, processalloc * sizeof(struct process))) == 0) die("realloc() failed\n ");
 		root = fump;
 	}
 	memmove(&root[++maxprocess], p, sizeof(struct process));
 }