[doldaconnect.git] / config / cmd / tthsum.c

/*
 *  Dolda Connect - Modular multiuser Direct Connect-style client
 *  Copyright (C) 2004 Fredrik Tolf <fredrik@dolda2000.com>
 *  
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *  
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *  
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/

/* This frankenfile is built from bits and pieces of the daemon. The
 * copying and pasting is very ugly, but it doesn't *really*
 * matter. */

#include <stdlib.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>
#include <fcntl.h>
#include <errno.h>
#include <sys/stat.h>

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include <tiger.h>
#include <utils.h>

char buf[32768];

static char *base64enc2(char *data, size_t datalen)
{
    static char *res = NULL;
    
    if(res != NULL)
	free(res);
    res = base64encode(data, datalen);
    return(res);
}

static char *base64dec2(char *data, size_t *datalen)
{
    static char *res = NULL;
    
    if(res != NULL)
	free(res);
    res = base64decode(data, datalen);
    return(res);
}

int main(int argc, char **argv)
{
    int i, ret;
    size_t size;
    int c, fd, outfd;
    int len, len2;
    int filter, output;
    struct tigertreehash tth;
    char *dec, *enc;
    char res[24];
    char *statefile;
    FILE *state;
    int progress, bytes;
    struct stat sb;
    
    filter = 0;
    output = 4;
    outfd = 3;
    progress = 0;
    statefile = NULL;
    while((c = getopt(argc, argv, "phf456F:s:")) != -1) {
	switch(c) {
	case '4':
	case '5':
	case '6':
	    output = c - '0';
	    break;
	case 'p':
	    progress = 1;
	    break;
	case 'f':
	    filter = 1;
	    break;
	case 'F':
	    outfd = atoi(optarg);
	    break;
	case 's':
	    statefile = optarg;
	    break;
	case 'h':
	case ':':
	case '?':
	default:
	    fprintf(stderr, "usage: tigersum [-h456] FILE...\n");
	    fprintf(stderr, "       tigersum [-h456] [-F OUTFD] [-s STATEFILE] -f\n");
	    exit((c == 'h')?0:1);
	}
    }
    if(filter) {
	inittigertree(&tth);
	if(statefile != NULL)
	{
	    if(((state = fopen(statefile, "r")) == NULL) && (errno != ENOENT)) {
		fprintf(stderr, "tigersum: %s: %s\n", statefile, strerror(errno));
		exit(1);
	    }
	    if(state != NULL) {
		if(fgets(buf, sizeof(buf), state) == NULL) {
		    fprintf(stderr, "tigersum: %s: could not read entire state\n", statefile);
		    exit(1);
		}
		tth.blocks = atoi(buf);
		if(fgets(buf, sizeof(buf), state) == NULL) {
		    fprintf(stderr, "tigersum: %s: could not read entire state\n", statefile);
		    exit(1);
		}
		tth.depth = atoi(buf);
		for(i = 0; i < tth.depth; i++) {
		    if(fgets(buf, sizeof(buf), state) == NULL) {
			fprintf(stderr, "tigersum: %s: could not read entire state\n", statefile);
			exit(1);
		    }
		    dec = base64dec2(buf, &size);
		    if(size != 24) {
			fprintf(stderr, "tigersum: %s: illegal state\n", statefile);
			exit(1);
		    }
		    memcpy(tth.stack[i], dec, 24);
		}
		if(fgets(buf, sizeof(buf), state) == NULL) {
		    fprintf(stderr, "tigersum: %s: could not read entire state\n", statefile);
		    exit(1);
		}
		tth.offset = atoi(buf);
		if(fgets(buf, sizeof(buf), state) == NULL) {
		    fprintf(stderr, "tigersum: %s: could not read entire state\n", statefile);
		    exit(1);
		}
		dec = base64dec2(buf, &size);
		if(size != tth.offset) {
		    fprintf(stderr, "tigersum: %s: illegal state\n", statefile);
		    exit(1);
		}
		memcpy(&tth.block, dec, tth.offset);
		fclose(state);
		unlink(statefile);
	    }
	}
	while(1) {
	    ret = read(0, buf, sizeof(buf));
	    if(ret < 0) {
		perror("tigersum: read");
		exit(1);
	    }
	    if(ret == 0)
		break;
	    len = ret;
	    for(len2 = 0; len2 < len; len2 += ret) {
		if((ret = write(1, buf, ret)) < 0) {
		    perror("tigersum: write");
		    exit(1);
		}
	    }
	    dotigertree(&tth, buf, len);
	}
	if(statefile != NULL) {
	    if((state = fopen(statefile, "w")) == NULL) {
		fprintf(stderr, "tigersum: %s: %s\n", statefile, strerror(errno));
		exit(1);
	    }
	    fprintf(state, "%i\n", tth.blocks);
	    fprintf(state, "%i\n", tth.depth);
	    for(i = 0; i < tth.depth; i++) {
		enc = base64enc2(tth.stack[i], 24);
		fprintf(state, "%s\n", enc);
	    }
	    fprintf(state, "%i\n", tth.offset);
	    enc = base64enc2(tth.block, tth.offset);
	    fputs(enc, state);
	    fputc('\n', state);
	    fclose(state);
	}
	synctigertree(&tth);
	restigertree(&tth, res);
	if(output == 4)
	    enc = hexencode(res, 24);
	else if(output == 5)
	    enc = base32encode(res, 24);
	else if(output == 6)
	    enc = base64encode(res, 24);
	for(len = 0; len < strlen(enc); len += ret) {
	    if((ret = write(outfd, enc + len, strlen(enc) - len)) < 0) {
		perror("tigersum: output");
		exit(1);
	    }
	}
	free(enc);
	write(outfd, "\n", 1);
    } else {
	for(i = optind; i < argc; i++) {
	    if(!strcmp(argv[i], "-")) {
		fd = 0;
	    } else {
		if((fd = open(argv[i], O_RDONLY)) < 0) {
		    fprintf(stderr, "tigersum: %s: %s\n", argv[i], strerror(errno));
		    exit(1);
		}
	    }
	    if(progress) {
		fstat(fd, &sb);
		if(!S_ISREG(sb.st_mode))
		    sb.st_size = -1;
		bytes = 0;
	    }
	    inittigertree(&tth);
	    while(1) {
		ret = read(fd, buf, sizeof(buf));
		if(ret < 0) {
		    perror("tigersum: read");
		    exit(1);
		}
		if(progress) {
		    if((bytes == 0) || ((bytes & ~0xFFFFF) != ((bytes + ret) & ~0xFFFFF))) {
			bytes += ret;
			fprintf(stderr, "\033[1G");
			if(argc - optind > 1)
			    fprintf(stderr, "%s: ", argv[i]);
			if(sb.st_size < 0) {
			    fprintf(stderr, "%i", bytes);
			} else {
			    fprintf(stderr, "%i%%", (int)(((float)bytes / (float)sb.st_size) * 100.0));
			}
			fprintf(stderr, "\033[K");
			fflush(stderr);
		    } else {
			bytes += ret;
		    }
		}
		if(ret == 0)
		    break;
		dotigertree(&tth, buf, ret);
	    }
	    if(progress)
		fprintf(stderr, "\n");
	    synctigertree(&tth);
	    restigertree(&tth, res);
	    if(output == 4)
		enc = hexencode(res, 24);
	    else if(output == 5)
		enc = base32encode(res, 24);
	    else if(output == 6)
		enc = base64encode(res, 24);
	    if(argc - optind > 1)
		printf("%s %s\n", enc, argv[i]);
	    else
		printf("%s\n", enc);
	    free(enc);
	    fflush(stdout);
	    close(fd);
	}
    }
    return(0);
}
Commit	Line	Data
	1	/*
	2	* Dolda Connect - Modular multiuser Direct Connect-style client
	3	* Copyright (C) 2004 Fredrik Tolf <fredrik@dolda2000.com>
	4	*
	5	* This program is free software; you can redistribute it and/or modify
	6	* it under the terms of the GNU General Public License as published by
	7	* the Free Software Foundation; either version 2 of the License, or
	8	* (at your option) any later version.
	9	*
	10	* This program is distributed in the hope that it will be useful,
	11	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	13	* GNU General Public License for more details.
	14	*
	15	* You should have received a copy of the GNU General Public License
	16	* along with this program; if not, write to the Free Software
	17	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	18	*/
	19
	20	/* This frankenfile is built from bits and pieces of the daemon. The
	21	* copying and pasting is very ugly, but it doesn't really
	22	* matter. */
	23
	24	#include <stdlib.h>
	25	#include <unistd.h>
	26	#include <stdio.h>
	27	#include <string.h>
	28	#include <fcntl.h>
	29	#include <errno.h>
	30	#include <sys/stat.h>
	31
	32	#ifdef HAVE_CONFIG_H
	33	#include <config.h>
	34	#endif
	35	#include <tiger.h>
	36	#include <utils.h>
	37
	38	char buf[32768];
	39
	40	static char base64enc2(char data, size_t datalen)
	41	{
	42	static char *res = NULL;
	43
	44	if(res != NULL)
	45	free(res);
	46	res = base64encode(data, datalen);
	47	return(res);
	48	}
	49
	50	static char base64dec2(char data, size_t *datalen)
	51	{
	52	static char *res = NULL;
	53
	54	if(res != NULL)
	55	free(res);
	56	res = base64decode(data, datalen);
	57	return(res);
	58	}
	59
	60	int main(int argc, char **argv)
	61	{
	62	int i, ret;
	63	size_t size;
	64	int c, fd, outfd;
	65	int len, len2;
	66	int filter, output;
	67	struct tigertreehash tth;
	68	char dec, enc;
	69	char res[24];
	70	char *statefile;
	71	FILE *state;
	72	int progress, bytes;
	73	struct stat sb;
	74
	75	filter = 0;
	76	output = 4;
	77	outfd = 3;
	78	progress = 0;
	79	statefile = NULL;
	80	while((c = getopt(argc, argv, "phf456F:s:")) != -1) {
	81	switch(c) {
	82	case '4':
	83	case '5':
	84	case '6':
	85	output = c - '0';
	86	break;
	87	case 'p':
	88	progress = 1;
	89	break;
	90	case 'f':
	91	filter = 1;
	92	break;
	93	case 'F':
	94	outfd = atoi(optarg);
	95	break;
	96	case 's':
	97	statefile = optarg;
	98	break;
	99	case 'h':
	100	case ':':
	101	case '?':
	102	default:
	103	fprintf(stderr, "usage: tigersum [-h456] FILE...\n");
	104	fprintf(stderr, " tigersum [-h456] [-F OUTFD] [-s STATEFILE] -f\n");
	105	exit((c == 'h')?0:1);
	106	}
	107	}
	108	if(filter) {
	109	inittigertree(&tth);
	110	if(statefile != NULL)
	111	{
	112	if(((state = fopen(statefile, "r")) == NULL) && (errno != ENOENT)) {
	113	fprintf(stderr, "tigersum: %s: %s\n", statefile, strerror(errno));
	114	exit(1);
	115	}
	116	if(state != NULL) {
	117	if(fgets(buf, sizeof(buf), state) == NULL) {
	118	fprintf(stderr, "tigersum: %s: could not read entire state\n", statefile);
	119	exit(1);
	120	}
	121	tth.blocks = atoi(buf);
	122	if(fgets(buf, sizeof(buf), state) == NULL) {
	123	fprintf(stderr, "tigersum: %s: could not read entire state\n", statefile);
	124	exit(1);
	125	}
	126	tth.depth = atoi(buf);
	127	for(i = 0; i < tth.depth; i++) {
	128	if(fgets(buf, sizeof(buf), state) == NULL) {
	129	fprintf(stderr, "tigersum: %s: could not read entire state\n", statefile);
	130	exit(1);
	131	}
	132	dec = base64dec2(buf, &size);
	133	if(size != 24) {
	134	fprintf(stderr, "tigersum: %s: illegal state\n", statefile);
	135	exit(1);
	136	}
	137	memcpy(tth.stack[i], dec, 24);
	138	}
	139	if(fgets(buf, sizeof(buf), state) == NULL) {
	140	fprintf(stderr, "tigersum: %s: could not read entire state\n", statefile);
	141	exit(1);
	142	}
	143	tth.offset = atoi(buf);
	144	if(fgets(buf, sizeof(buf), state) == NULL) {
	145	fprintf(stderr, "tigersum: %s: could not read entire state\n", statefile);
	146	exit(1);
	147	}
	148	dec = base64dec2(buf, &size);
	149	if(size != tth.offset) {
	150	fprintf(stderr, "tigersum: %s: illegal state\n", statefile);
	151	exit(1);
	152	}
	153	memcpy(&tth.block, dec, tth.offset);
	154	fclose(state);
	155	unlink(statefile);
	156	}
	157	}
	158	while(1) {
	159	ret = read(0, buf, sizeof(buf));
	160	if(ret < 0) {
	161	perror("tigersum: read");
	162	exit(1);
	163	}
	164	if(ret == 0)
	165	break;
	166	len = ret;
	167	for(len2 = 0; len2 < len; len2 += ret) {
	168	if((ret = write(1, buf, ret)) < 0) {
	169	perror("tigersum: write");
	170	exit(1);
	171	}
	172	}
	173	dotigertree(&tth, buf, len);
	174	}
	175	if(statefile != NULL) {
	176	if((state = fopen(statefile, "w")) == NULL) {
	177	fprintf(stderr, "tigersum: %s: %s\n", statefile, strerror(errno));
	178	exit(1);
	179	}
	180	fprintf(state, "%i\n", tth.blocks);
	181	fprintf(state, "%i\n", tth.depth);
	182	for(i = 0; i < tth.depth; i++) {
	183	enc = base64enc2(tth.stack[i], 24);
	184	fprintf(state, "%s\n", enc);
	185	}
	186	fprintf(state, "%i\n", tth.offset);
	187	enc = base64enc2(tth.block, tth.offset);
	188	fputs(enc, state);
	189	fputc('\n', state);
	190	fclose(state);
	191	}
	192	synctigertree(&tth);
	193	restigertree(&tth, res);
	194	if(output == 4)
	195	enc = hexencode(res, 24);
	196	else if(output == 5)
	197	enc = base32encode(res, 24);
	198	else if(output == 6)
	199	enc = base64encode(res, 24);
	200	for(len = 0; len < strlen(enc); len += ret) {
	201	if((ret = write(outfd, enc + len, strlen(enc) - len)) < 0) {
	202	perror("tigersum: output");
	203	exit(1);
	204	}
	205	}
	206	free(enc);
	207	write(outfd, "\n", 1);
	208	} else {
	209	for(i = optind; i < argc; i++) {
	210	if(!strcmp(argv[i], "-")) {
	211	fd = 0;
	212	} else {
	213	if((fd = open(argv[i], O_RDONLY)) < 0) {
	214	fprintf(stderr, "tigersum: %s: %s\n", argv[i], strerror(errno));
	215	exit(1);
	216	}
	217	}
	218	if(progress) {
	219	fstat(fd, &sb);
	220	if(!S_ISREG(sb.st_mode))
	221	sb.st_size = -1;
	222	bytes = 0;
	223	}
	224	inittigertree(&tth);
	225	while(1) {
	226	ret = read(fd, buf, sizeof(buf));
	227	if(ret < 0) {
	228	perror("tigersum: read");
	229	exit(1);
	230	}
	231	if(progress) {
	232	if((bytes == 0) \|\| ((bytes & ~0xFFFFF) != ((bytes + ret) & ~0xFFFFF))) {
	233	bytes += ret;
	234	fprintf(stderr, "\033[1G");
	235	if(argc - optind > 1)
	236	fprintf(stderr, "%s: ", argv[i]);
	237	if(sb.st_size < 0) {
	238	fprintf(stderr, "%i", bytes);
	239	} else {
	240	fprintf(stderr, "%i%%", (int)(((float)bytes / (float)sb.st_size) * 100.0));
	241	}
	242	fprintf(stderr, "\033[K");
	243	fflush(stderr);
	244	} else {
	245	bytes += ret;
	246	}
	247	}
	248	if(ret == 0)
	249	break;
	250	dotigertree(&tth, buf, ret);
	251	}
	252	if(progress)
	253	fprintf(stderr, "\n");
	254	synctigertree(&tth);
	255	restigertree(&tth, res);
	256	if(output == 4)
	257	enc = hexencode(res, 24);
	258	else if(output == 5)
	259	enc = base32encode(res, 24);
	260	else if(output == 6)
	261	enc = base64encode(res, 24);
	262	if(argc - optind > 1)
	263	printf("%s %s\n", enc, argv[i]);
	264	else
	265	printf("%s\n", enc);
	266	free(enc);
	267	fflush(stdout);
	268	close(fd);
	269	}
	270	}
	271	return(0);
	272	}