rohrpost

ind.c (8246B)

---

 /*
  * Copy me if you can.
  * by 20h
  */
 
 #include <unistd.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <stdarg.h>
 #include <fcntl.h>
 #include <string.h>
 #include <strings.h>
 #include <errno.h>
 #include <ctype.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <time.h>
 #include <limits.h>
 
 #include "ind.h"
 
 void
 edie(char *fmt, ...)
 {
 	va_list fmtargs;
 
 	va_start(fmtargs, fmt);
 	vfprintf(stderr, fmt, fmtargs);
 	va_end(fmtargs);
 	fprintf(stderr, ": ");
 
 	perror(NULL);
 
 	exit(1);
 }
 
 void
 die(char *fmt, ...)
 {
 	va_list fmtargs;
 
 	va_start(fmtargs, fmt);
 	vfprintf(stderr, fmt, fmtargs);
 	va_end(fmtargs);
 
 	exit(1);
 }
 
 void *
 reallocz(void *p, int l, int z)
 {
         p = realloc(p, l);
         if(p == NULL)
 		edie("realloc");
         if(z)
 		memset(p, 0, l);
 
         return p;
 }
 
 void *
 mallocz(int l, int z)
 {
 	return reallocz(NULL, l, z);
 }
 
 void *
 memdup(void *p, int l)
 {
         char *ret;
 
         ret = reallocz(NULL, l, 2);
         memmove(ret, p, l);
 
         return (void *)ret;
 }
 
 void *
 memdupz(void *p, int l)
 {
 	char *ret;
 
 	ret = reallocz(NULL, l+1, 2);
 	memmove(ret, p, l);
 
 	return (void *)ret;
 }
 
 void *
 memdups(void *p)
 {
         char *ret;
 	int l;
 
 	l = strlen(p) + 1;
 
         ret = reallocz(NULL, l, 2);
         memmove(ret, p, l);
 
         return (void *)ret;
 }
 
 /*
  * Append the data at c with the length of lc to
  * p, at position lp of p.
  */
 void *
 memdupcat(void *p, int lp, void *c, int lc)
 {
 	p = reallocz(p, lp+lc, 0);
 	memset(&((char *)p)[lp], 0, lc);
 
 	memmove(&((char *)p)[lp], c, lc);
 
 	return p;
 }
 
 char *
 vsmprintf(char *fmt, va_list fmtargs, int size)
 {
 	char *ret;
 
 	ret = reallocz(NULL, ++size, 2);
 	vsnprintf(ret, size, fmt, fmtargs);
 
 	return ret;
 }
 
 char *
 smprintf(char *fmt, ...)
 {
 	va_list fmtargs;
 	char *ret;
 	int len;
 
 	va_start(fmtargs, fmt);
 	len = vsnprintf(NULL, 0, fmt, fmtargs);
 	va_end(fmtargs);
 
 	if (len == INT_MAX)
 		return NULL;
 
 	va_start(fmtargs, fmt);
 	ret = vsmprintf(fmt, fmtargs, len);
 	va_end(fmtargs);
 
 	return ret;
 }
 
 void
 setnonblocking(int fd)
 {
 	int opts;
 
 	opts = fcntl(fd, F_GETFL);
 	if(opts < 0)
 		edie("setnonblocking");
 
 	if(fcntl(fd, F_SETFL, opts | O_NONBLOCK) < 0)
 		edie("setnonblocking");
 }
 
 void
 setblocking(int fd)
 {
 	int opts;
 
 	opts = fcntl(fd, F_GETFL);
 	if(opts < 0)
 		edie("setblocking");
 
 	if(fcntl(fd, F_SETFL, opts & ~O_NONBLOCK) < 0)
 		edie("setblocking");
 }
 
 int
 runcmd(char *cmd, int *infd, int *outfd, int *errfd, int keepold)
 {
 	int pid, nullfd, status;
 	int pstdin[2], pstdout[2], pstderr[2];
 
 	enum {
 		DOSTDOUT = 0x01,
 		DOSTDIN = 0x02,
 		DOSTDERR = 0x04,
 		HAVENULLFD = 0x08
 	};
 
 	status = 0;
 
 	if (infd) {
 		if (pipe(pstdin))
 			goto runcmderror;
 		status |= DOSTDOUT;
 	}
 	if (outfd) {
 		if (pipe(pstdout))
 			goto runcmderror;
 		status |= DOSTDIN;
 	}
 	if (errfd) {
 		if (pipe(pstderr))
 			goto runcmderror;
 		status |= DOSTDERR;
 	}
 	if (!keepold && ((status & DOSTDIN) || (status & DOSTDOUT)
 			|| (status & DOSTDERR))) {
 		nullfd = open("/dev/null", O_RDWR);
 		if (nullfd < 0)
 			goto runcmderror;
 		status |= HAVENULLFD;
 	}
 
 	pid = fork();
 	switch(pid) {
 	case -1:
 		return pid;
 	case 0:
 		if (status & DOSTDIN) {
 			close(pstdin[1]);
 			dup2(pstdin[0], 0);
 		} else {
 			if (!keepold)
 				dup2(nullfd, 0);
 		}
 		if (status & DOSTDOUT) {
 			close(pstdout[0]);
 			dup2(pstdout[1], 1);
 		} else {
 			if (!keepold)
 				dup2(nullfd, 1);
 		}
 		if (status & DOSTDERR) {
 			close(pstderr[1]);
 			dup2(pstderr[0], 2);
 		} else {
 			if (!keepold)
 				dup2(nullfd, 2);
 		}
 
 		execl("/bin/sh", "sh", "-c", cmd, NULL);
 		exit(1);
 	default:
 		break;
 	}
 
 	if (status & DOSTDIN) {
 		close(pstdin[0]);
 		*infd = pstdin[1];
 	}
 	if (status & DOSTDOUT) {
 		close(pstdout[1]);
 		*outfd = pstdout[0];
 	}
 	if (status & DOSTDERR) {
 		close(pstderr[1]);
 		*errfd = pstderr[1];
 	}
 
 	return pid;
 runcmderror:
 	if (status & DOSTDIN) {
 		close(pstdin[0]);
 		close(pstdin[1]);
 	}
 	if (status & DOSTDOUT) {
 		close(pstdout[0]);
 		close(pstdout[1]);
 	}
 	if (status & DOSTDERR) {
 		close(pstderr[0]);
 		close(pstderr[1]);
 	}
 	if (status & HAVENULLFD)
 		close(nullfd);
 
 	return -1;
 }
 
 char *
 expandhome(char *path)
 {
 	char *home, *retpath;
 
 	retpath = NULL;
 
 	if (path[0] == '~') {
 		home = getenv("HOME");
 		if (home != NULL)
 			retpath = smprintf("%s%s", home, path+1);
 	}
 	if (retpath == NULL)
 		retpath = memdups(path);
 
 	return retpath;
 }
 
 int
 writeall(FILE *fd, void *data, int len)
 {
 	int written;
 
 	for (written = 0; len > 0; ) {
 		written = fwrite(data, 1, len, fd);
 		len -= written;
 	}
 
 	return 0;
 }
 
 int
 writeallfd(int fd, void *data, int len)
 {
 	int written;
 
 	for (written = 0; len > 0; ) {
 		written = write(fd, &((char *)data)[written], len);
 		len -= written;
 	}
 
 	return 0;
 }
 
 int
 writefile(char *file, void *data, int len, char *mode)
 {
 	FILE *fd;
 
 	fd = fopen(file, mode);
 	if (fd == NULL)
 		return 1;
 	if (writeall(fd, data, len))
 		return 1;
 	fclose(fd);
 
 	return 0;
 }
 
 int
 getfilesize(char *file)
 {
 	struct stat fs;
 
 	if (stat(file, &fs) < 0)
 		return -1;
 
 	return fs.st_size;
 }
 
 char *
 readtoeof(FILE *fd, int *len)
 {
 	char *ret, buf[4096];
 	int olen, nlen, rl;
 
 	for (nlen = 0, olen = 0, ret = NULL; !feof(fd); olen = nlen) {
 		rl = fread(buf, 1, sizeof(buf), fd);
 		if (rl > 0) {
 			nlen += rl;
 			ret = reallocz(ret, nlen+1, 0);
 			ret[nlen] = '\0';
 
 			memmove(&ret[olen], buf, rl);
 		}
 	}
 
 	*len = nlen;
 	return ret;
 }
 
 char *
 readtoeoffd(int fd, int *len)
 {
 	char *ret, buf[4096];
 	int olen, nlen, rl;
 
 	for (nlen = 0, olen = 0, ret = NULL;
 			(rl = read(fd, buf, sizeof(buf))); olen = nlen) {
 		if (rl > 0) {
 			nlen += rl;
 			ret = reallocz(ret, nlen+1, 0);
 			ret[nlen] = '\0';
 
 			memmove(&ret[olen], buf, rl);
 		}
 	}
 
 	*len = nlen;
 	return ret;
 }
 
 char *
 readfile(char *file, int *len)
 {
 	FILE *fd;
 	char *data;
 
 	fd = fopen(file, "r");
 	if (fd == NULL)
 		return NULL;
 
 	data = readtoeof(fd, len);
 	fclose(fd);
 
 	return data;
 }
 
 char *
 readstdin(int *len)
 {
 	return readtoeof(stdin, len);
 }
 
 /*
  * Get line from string buffer.
  */
 char *
 sgets(char *s, int size, char **p)
 {
 	char *np;
 	int cl;
 
 	if (*p == NULL)
 		return NULL;
 
 	np = strchr(*p, '\n');
 	if (np == NULL) {
 		cl = strlen(*p);
 		if (cl < 1) {
 			*p = NULL;
 			return NULL;
 		}
 	} else {
 		cl = np - *p;
 	}
 
 	if (cl >= size)
 		cl = size - 1;
 	memmove(s, *p, cl);
 	s[cl] = '\0';
 
 	if (np == NULL) {
 		*p = NULL;
 	} else {
 		*p = np+1;
 	}
 
 	return s;
 }
 
 char *
 sgetuntil(char *str, char **p, char *max, int *len)
 {
 	char *ret, *op;
 	int si;
 
 	ret = NULL;
 
 	si = 0;
 	for (op = *p; op < max; op++) {
 		if (str[si] == '\0')
 			break;
 		if (op[0] == str[si]) {
 			si++;
 		} else {
 			si = 0;
 		}
 	}
 	if (str[si] == '\0') {
 		*len = op - *p - strlen(str);
 		ret = memdupz(*p, *len);
 		*p = op;
 	}
 
 	return ret;
 }
 
 char *
 strrlnspn(char *p, char *chars, int limit)
 {
 	char *np;
 
 	np = &p[limit-1];
 	for(; !strchr(chars, np[0] && p != np); np--);
 
 	return np;
 }
 
 int
 strisascii(char *str)
 {
 	int len, i;
 
 	len = strlen(str);
 	for (i = 0; i < len; i++) {
 		if (!isascii(str[i]))
 			return 0;
 	}
 
 	return 1;
 }
 
 void
 strnormalizespace(char *str)
 {
 	int len, i;
 
 	len = strlen(str);
 	for (i = 0; i < len; i++) {
 		if (isspace(str[i]))
 			str[i] = ' ';
 	}
 }
 
 /*
  * Find a whitespace character in a certain limit. This is used for formatting
  * mail to a certain width.
  */
 char *
 findlimitws(char *str, int limit)
 {
 	int len;
 	char *ptr;
 
 	len = strlen(str);
 	if (len < limit)
 		return NULL;
 
 	ptr = strrlnspn(str, "\t\r\v\f ", limit);
 	if (ptr == str)
 		return &str[limit-1];
 	return ptr;
 }
 
 char *
 mktmpfile(char *prefix, char *suffix, int *fd)
 {
 	char *name;
 	time_t tm;
 	int tfd;
 
 	tm = time(NULL);
 	srand(tm);
 
 	for (tfd = -1; tfd < 0;) {
 		name = smprintf("/tmp/%s.%d.%d.%s", prefix, getpid(), rand(),
 				suffix);
 		tfd = open(name, O_EXCL|O_CREAT|O_RDWR|O_TRUNC,
 				S_IRUSR|S_IWUSR);
 		if (tfd >= 0)
 			break;
 		if (tfd < 0 && errno != EEXIST)
 			edie("mktmpfile");
 		free(name);
 	}
 
 	*fd = tfd;
 
 	return name;
 }
 
 int
 intcmp(const void *p1, const void *p2)
 {
 	return *((int *)p1) - *((int *)p2);
 }
 
 char *
 smftime(char *fmt, const struct tm *tm)
 {
 	int len, rlen;
 	char *ret;
 
 	len = strlen(fmt);
 	ret = NULL;
 	for (; len < 1024;) {
 		len *= 2;
 		ret = reallocz(ret, len, 0);
 		rlen = strftime(ret, len, fmt, tm);
 		if (rlen == 0)
 			continue;
 	}
 
 	return ret;
 }