// rc2.c, version 0.2.0
// OMKOV cryptutils rc2
// Copyright (C) 2021, Jakob Wakeling
// MIT Licence

#include "util/error.c"
#include "util/optget.h"
#include "util/rc2.h"
#include "util/util.h"

#include <limits.h>
#include <stdio.h>
#include <string.h>

#define VERSION "0.2.0"

static struct lop lops[] = {
	{ "help",    ARG_NUL, 256 },
	{ "version", ARG_NUL, 257 },
	{ NULL, 0, 0 }
};

static int mode = 0;
static char *karg;
static int larg;

static inline void rc2(const char *ifile, const char *ofile);

static void hlp(void);
static void ver(void);

int main(int ac, char *av[]) { A0 = av[0];
	struct opt opt = OPTGET_INIT; opt.str = "dek:l:m"; opt.lops = lops;
	for (int o; (o = optget(&opt, av, 1)) != -1;) switch (o) {
	case 'e': { mode = 0; } break;
	case 'd': { mode = 1; } break;
	case 'k': { karg = opt.arg; } break;
	case 'l': {
		register int d; register char *p = opt.arg;
		for (larg = 0; *p >= '0' && *p < '9'; ++p) {
			d = (int)*p - '0';
			if (larg > (INT_MAX - d) / 10) { break; }
			larg = larg * 10 + d;
		}
		
		if (*p) { error(1, "invalid length"); }
		if (larg > 1024) { error(1, "length must be at most 1024"); }
		if (larg == 0) { error(1, "length must be greater than 0"); }
	} break;
	case 'm': { /* TODO */ error(1, "-m not implemented"); } break;
	case 256: { hlp(); } return 0;
	case 257: { ver(); } return 0;
	default: {} return 1;
	}
	
	if (!larg) { larg = 1024; }
	
	if (opt.ind == ac) { error(1, "missing operand"); }
	else if (opt.ind == ac - 1) { rc2(av[opt.ind], NULL); }
	else if (opt.ind == ac - 2) { rc2(av[opt.ind], av[opt.ind + 1]); }
	else { error(1, "excess operand"); }
	
	return 0;
}

static inline void rc2(const char *ifile, const char *ofile) {
	struct rc2 ctx; u8 b1[128], b2[16]; FILE *fk, *fi, *fo; size_t kl, fl;
	
	if (!karg) { error(1, "-k is required"); }
	else if (!(fk = fopen(karg, "r"))) { error(1, "%s: %s", karg, serr()); }
	
	// TODO Check key size is within bounds
	kl = fread(b1, 1, sizeof (b1), fk); fclose(fk); fk = NULL;
	rc2expand(&ctx, b1, kl, larg);
	
	if (!ifile) { fi = stdin; }
	else if (!(fi = fopen(ifile, "r"))) { error(1, "%s: %s", ifile, serr()); }
	
	if (!ofile) { fo = stdout; }
	else if (!(fo = fopen(ofile, "w"))) { error(1, "%s: %s", ofile, serr()); }
	
	for (size_t c; (c = fread(b1, 1, 8, fi));) {
		while (c >= 8) {
			memset(b2, 0, 8);
			if (mode == 0) { rc2encrypt(&ctx, b1, b2); }
			if (mode == 1) { rc2decrypt(&ctx, b1, b2); }
			fwrite(b2, 1, 8, fo); c -= 8;
		}
		
		if (c != 0) { // Should only be true during encryption
			memset(b2, 0, 8);
			if (mode == 0) { rc2encrypt(&ctx, b1, b2); }
			fwrite(b2, 1, 8, fo);
		}
		
		memset(b1, 0, 8);
	}
	
	if (fi != stdin) { fclose(fi); }
	if (fo != stdin) { fclose(fo); }
	
	return;
}

/* Print help information. */
static void hlp(void) {
	puts("rc2 - encrypt and decrypt files using rc2\n");
	puts("usage: rc2 [-d|-e] [-k keyfile] [-l length] [-m mode] [infile] "
			"[outfile]\n");
	puts("options:");
	puts("  -d         Decrypt the input data");
	puts("  -e         Encrypt the input data (default)");
	puts("  -k file    Specify keyfile");
	puts("  -l length  Override effective key length");
	puts("  -m mode    Specify block cipher mode of operation");
	puts("  --help     Display help information");
	puts("  --version  Display version information");
}

/* Print version information. */
static void ver(void) {
	puts("OMKOV cryptutils rc2, version " VERSION);
	puts("Copyright (C) 2021, Jakob Wakeling");
	puts("MIT Licence (https://opensource.org/licenses/MIT)");
}