src/Wip/dj/dj.c

#include <errno.h> /* errno */
#include <fcntl.h> /* open(2) */
#include <stdio.h> /* fprintf(3), stderr */
#include <stdlib.h> /* free(3), malloc(3), strtol(3), size_t */
#include <string.h> /* memset(3) */
#include <sysexits.h> /* EX_OK, EX_USAGE */
#include <unistd.h> /* close(2), getopt(3), read(2), write(2), optarg, optind,
                       STDIN_FILENO, STDOUT_FILENO */

#define ARGV0 (argv[0] == NULL ? "<no argv[0]>" : argv[0])
#define fdisnotstd(fd) \
		((fd) != STDIN_FILENO \
		&& (fd) != STDOUT_FILENO \
		&& (fd) != STDERR_FILENO)

/* information that needs to be kept about each file in the "pipe" */
struct Io{
	size_t index;	/* index in io[] array */
	char *fn;		/* file name (may be stdin_name or stdout_name) */
	int rec;		/* records processed */
	int prec;		/* partial records processed */
	int fd;			/* file descriptor */
	int seek;		/* bytes to seek/skip (will be 0 after skippage) */
	int bs;			/* buffer size */
	size_t bufuse;	/* buffer usage */
	char *buf;		/* buffer */
};

static char stdin_name = "<stdin>";
static char stdout_name = "<stdout>";

static void
Io_setdefaults(struct Io io[2]){

	io[0].bs = io[1].bs = 1024;
	io[0].buf = io[1].buf = NULL;
	io[0].fd = STDIN_FILENO;
	io[0].fn = stdin_name;
	io[1].fd = STDOUT_FILENO;
	io[1].fn = stdout_name;
	io[0].index = 0;
	io[1].index = 1;
	io[0].seek = io[1].seek = 0;

	return;
}

/* read(2) but with a second chance if it returns zero */
static int
_read(int fd, void *b, size_t bs){
	int retval;

	return ((retval = read(fd, buf, bs)) == 0)
		? read(fd, buf, bs)
		: retval;
}

static int /* on error returns -1, else returns non-negative */
parse(char *s){
	int r;

	errno = 0;

	return (*s == '\0' /* empty string */
			|| *(s = (int)strtol(s, &s, 0)) != '\0' /* not fully processed */
			|| errno != 0)
		? -1
		: r;
}

/* s is the component (e.g. filename) that failed */
static int
oserr(char *argv0, char *s){
	fprintf(stderr, "%s: %s: %s\n", argv0, s, strerror(errno));
	return EX_OSERR;
}

/* diagnostic output
 * dd(1p) does %d+%d\n%d+%d\n */
struct Io *
output(struct Io io[2]){

	fprintf(stderr, "%d:%d / %d:%d\n",
		io[0].rec, io[0].prec, io[1].rec, io[1].prec);;
	return io;
}

static int
terminate(struct Io io[2]){

	for(;; ++io){
		if(fdisnotstd(io->fd))
			close(io->fd);
		free(io->buf);
		if(io->index == 1)
			break;
	}

	return EX_OK;
}

static int
usage(char *argv0){

	fprintf(stderr, "Usage: %s (-af) (-c [count]\n"
		"\t(-i [input file]) (-b [input block size])"
			" (-s [input offset])\n"
		"\t(-o [output file]) (-B [output block size])"
			" (-S [output offset])\n", ARGV0);
	return EX_USAGE;
}


int main(int argc, char *argv[]){
	char align;
	char noerror;
	int c;
	int count;
	int p; /* pipe side */
	struct Io io[2]; /* { read, write } same as pipe(2) */

	/* defaults */
	align = 0;
	count = 0;
	noerror = 0;
	Io_setdefaults(io);

	if(argc > 0)
		while((c = getopt(argc, argv, "ac:i:b:fs:o:B:S:")) != -1)
			if(c == 'i' || c == 'o'){ /* file arguments */
				int t;

				p = (c == 'o');
				if(		((t = open(optarg,
								c == 'i'
								? O_RDONLY
								: O_WRONLY | O_CREAT))
							== -1)
						|| (fdisnotstd(io[p].fd)
							&& close(io[p].fd) != 0)){
					terminate(io);
					return oserr(argv[0], optarg);
				}else{
					io[p].fd = t;
					io[p].fn = optarg;
				}
			/* boolean arguments */
			}else if(c == 'a')
				align = 1;
			else if(c == 'f')
				noerror = 1;
			/* numeric arguments */
			else if(!((c == 'c' && (count = parse(optarg)) < 0)
					|| (c == 'b' && (io[0].bs = parse(optarg)) < 0)
					|| (c == 's' && (io[0].seek = parse(optarg)) < 0)
					|| (c == 'B' && (io[1].bs = parse(optarg)) < 0)
					|| (c == 'S' && (io[1].seek = parse(optarg)) < 0))){
				terminate(io);
				return usage(argv[0]);
			}

	if(argc > optind)
		return usage(argv[0]);

	for(p = 0; p <= 1; ++p){
		/* buffer alloc */
		if((io[p].buf = malloc(io[p].bs * (sizeof io[p].buf))) == NULL){
			fprintf(stderr, "%s: Failed to allocate %d bytes\n", ARGV0,
				io[p].bs);
			terminate(io);
			return EX_OSERR;
		}else if(io[p].seek > 0){ /* seek */
			if(!fdisnotstd(io[p].fd)
					|| lseek(io[p].fd, io[p].seek, SEEK_SET) == -1){					
				if(p == 0){
					do	if((io[p].bufuse = _read(io[p].fd, io[p].buf,
									io[p].bs < io[p].seek
										? io[p].bs
										: io[p].seek))
								!= 0)
							io[p].seek -= io[p].bufuse;
						else /* not enough to skip */
							return terminate(output(io));
					while(io[p].seek > 0);
				}else{
					memset(io[p].buf, '\0', io[p].bs);
					/* cheat and use bufuse as the retval for write
					 * (the buffer is zeroed, it doesn't matter) */
					do	if((io[p].bufuse = write(io[p].fd, io[p].buf,
									io[p].bs < io[p].seek
										? io[p].bs
										: io[p].seek))
								!= 0)
							io[p].seek -= io[p].bufuse;
						else
							return terminate(output(io));
					while(io[p].seek > 0);
				}
			}
		}
	}

	io[0].prec = io[0].rec = io[1].prec = io[1].rec = 0;

	do{	/* read */ if((io[0].bufuse
				= read(io[0].fd, io[0].buf, io[0].bs))
				< io[0].bs){
			if(io[0].bufuse == 0 && (!noerror
					|| ((io[0].bufuse = read(io[0].fd, io[0].buf, io[0].bs))
						== 0)))
				break; /* that's all she wrote */
			else{
				io[0].prec += 1;
				if(noerror){
					
				}else
					count = 1;
				if(align){
					memset(io[0].buf + io[0].bufuse, '\0',
						io[0].bs - io[0].bufuse);
					io[0].bufuse = io[0].bs;
				}
			}
		}

		/* write */ while(io[0].bufuse > 0){
		}
	}while(count == 0 || --count > 0);

	return terminate(output(io));
}