Fix CVS cruft. Fix some build problems. Make hashsum understand some new

encodings.

diff --git a/ec-test.c b/ec-test.c
index e83e3ee..30d1069 100644 (file)
--- a/ec-test.c
+++ b/ec-test.c
@@ -1,6 +1,6 @@
 /* -*-c-*-
  *
- * $Id: ec-test.c,v 1.6 2004/04/08 01:36:15 mdw Exp $
+ * $Id$
  *
  * Code for testing elliptic-curve stuff
  *
@@ -189,7 +189,7 @@ static void ecdump(dstr *d, FILE *fp)
   ecdodump(a, fp);
 }
 
-test_type type_ec = { eccvt, ecdump };
+const test_type type_ec = { eccvt, ecdump };
 
 /*----- Testing elliptic curve functionality ------------------------------*/
 

diff --git a/hashsum.c b/hashsum.c
index a175397..dbb6662 100644 (file)
--- a/hashsum.c
+++ b/hashsum.c
@@ -1,6 +1,6 @@
 /* -*-c-*-
  *
- * $Id: hashsum.c,v 1.10 2004/04/08 01:36:15 mdw Exp $
+ * $Id$
  *
  * Hash files using some secure hash function
  *
@@ -31,6 +31,7 @@
 
 #include "config.h"
 
+#include <assert.h>
 #include <ctype.h>
 #include <errno.h>
 #include <stdio.h>
@@ -45,6 +46,10 @@
 #include <mLib/sub.h>
 #include <mLib/str.h>
 
+#include <mLib/hex.h>
+#include <mLib/base32.h>
+#include <mLib/base64.h>
+
 #include "ghash.h"
 
 /*----- Static variables --------------------------------------------------*/
@@ -57,6 +62,131 @@
 #define f_raw 32u
 #define f_oddhash 64u
 #define f_escape 128u
+#define f_oddenc 256u
+
+/*----- Encoding and decoding ---------------------------------------------*/
+
+/* --- Hex encoding --- */
+
+static void puthex(const octet *buf, size_t sz, FILE *fp)
+{
+  while (sz) {
+    fprintf(fp, "%02x", *buf++);
+    sz--;
+  }
+}
+
+static size_t gethex(const char *p, octet *q, size_t sz, char **pp)
+{
+  size_t i = 0;
+  while (sz > 0 &&
+        isxdigit((unsigned char)p[0]) &&
+        isxdigit((unsigned char)p[1])) {
+    char buf[3];
+    buf[0] = p[0];
+    buf[1] = p[1];
+    buf[2] = 0;
+    *q++ = strtoul(buf, 0, 16);
+    sz--;
+    p += 2;
+    i++;
+  }
+  if (pp)
+    *pp = (char *)p;
+  return (i); 
+}
+
+/* --- Base64 encoding --- */
+
+static void putb64(const octet *buf, size_t sz, FILE *fp)
+{
+  base64_ctx b;
+  dstr d = DSTR_INIT;
+
+  base64_init(&b);
+  b.indent = "";
+  b.maxline = 0;
+  base64_encode(&b, buf, sz, &d);
+  base64_encode(&b, 0, 0, &d);
+  dstr_write(&d, fp);
+  dstr_destroy(&d);
+}
+
+static size_t getb64(const char *p, octet *q, size_t sz, char **pp)
+{
+  base64_ctx b;
+  dstr d = DSTR_INIT;
+  size_t n = strlen(p);
+
+  base64_init(&b);
+  base64_decode(&b, p, n, &d);
+  if (pp) *pp = (/*unconst*/ char *)p + n;
+  base64_decode(&b, 0, 0, &d);
+  assert(d.len <= sz);
+  memcpy(q, d.buf, sz);
+  n = d.len;
+  dstr_destroy(&d);
+  return (n);
+}
+
+/* --- Base32 encoding --- */
+
+static void putb32(const octet *buf, size_t sz, FILE *fp)
+{
+  base32_ctx b;
+  dstr d = DSTR_INIT;
+
+  base32_init(&b);
+  b.indent = "";
+  b.maxline = 0;
+  base32_encode(&b, buf, sz, &d);
+  base32_encode(&b, 0, 0, &d);
+  dstr_write(&d, fp);
+  dstr_destroy(&d);
+}
+
+static size_t getb32(const char *p, octet *q, size_t sz, char **pp)
+{
+  base32_ctx b;
+  dstr d = DSTR_INIT;
+  size_t n = strlen(p);
+
+  base32_init(&b);
+  base32_decode(&b, p, n, &d);
+  if (pp) *pp = (/*unconst*/ char *)p + n;
+  base32_decode(&b, 0, 0, &d);
+  assert(d.len <= sz);
+  memcpy(q, d.buf, sz);
+  n = d.len;
+  dstr_destroy(&d);
+  return (n);
+}
+
+/* --- Table --- */
+
+typedef struct encops {
+  const char *name;
+  void (*put)(const octet *, size_t, FILE *);
+  size_t (*get)(const char *, octet *, size_t, char **);
+} encops;
+
+static const encops enctab[] = {
+  { "hex", puthex, gethex },
+  { "base64", putb64, getb64 },
+  { "base32", putb32, getb32 },
+  { 0, 0, 0 }
+};
+
+static const encops *getenc(const char *ename)
+{
+  const encops *e;
+
+  for (e = enctab; e->name; e++) {
+    if (strcmp(ename, e->name) == 0)
+      return (e);
+  }
+  return (0);
+}
 
 /*----- Support functions -------------------------------------------------*/
 
@@ -96,57 +226,6 @@ static int fhash(const char *file, unsigned f, const gchash *gch, void *buf)
   return (e ? -1 : 0);
 }
 
-/* --- @puthex@ --- *
- *
- * Arguments:  @const octet *buf@ = pointer to a binary buffer
- *             @size_t sz@ = size of the buffer
- *             @FILE *fp@ = pointer to output file handle
- *
- * Returns:    ---
- *
- * Use:                Writes a hex dump of a block of memory.
- */
-
-static void puthex(const octet *buf, size_t sz, FILE *fp)
-{
-  while (sz) {
-    fprintf(fp, "%02x", *buf++);
-    sz--;
-  }
-}
-
-/* --- @gethex@ --- *
- *
- * Arguments:  @const char *p@ = pointer to input string
- *             @octet *q@ = pointer to output buffer
- *             @size_t sz@ = size of the output buffer
- *             @char **pp@ = where to put the end pointer
- *
- * Returns:    The number of bytes written to the buffer.
- *
- * Use:                Reads hex dumps from the input string.
- */
-
-static size_t gethex(const char *p, octet *q, size_t sz, char **pp)
-{
-  size_t i = 0;
-  while (sz > 0 &&
-        isxdigit((unsigned char)p[0]) &&
-        isxdigit((unsigned char)p[1])) {
-    char buf[3];
-    buf[0] = p[0];
-    buf[1] = p[1];
-    buf[2] = 0;
-    *q++ = strtoul(buf, 0, 16);
-    sz--;
-    p += 2;
-    i++;
-  }
-  if (pp)
-    *pp = (char *)p;
-  return (i); 
-}
-
 /* --- @gethash@ --- *
  *
  * Arguments:  @const char *name@ = pointer to name string
@@ -351,7 +430,8 @@ static void putstring(FILE *fp, const char *p, unsigned raw)
 
 /*----- Guts --------------------------------------------------------------*/
 
-static int checkhash(const char *file, unsigned f, const gchash *gch)
+static int checkhash(const char *file, unsigned f,
+                    const gchash *gch, const encops *e)
 {
   int rc;
   FILE *fp;
@@ -387,6 +467,13 @@ static int checkhash(const char *file, unsigned f, const gchash *gch)
        gch = g;
        xfree(buf);
        buf = xmalloc(2 * gch->hashsz);
+      } else if (strcmp(q, "encoding") == 0) {
+       const encops *ee;
+       if ((q = str_getword(&p)) == 0)
+         continue;
+       if ((ee = getenc(q)) == 0)
+         continue;
+       e = ee;
       } else if (strcmp(q, "escape") == 0)
        f |= f_escape;
       continue;
@@ -400,7 +487,7 @@ static int checkhash(const char *file, unsigned f, const gchash *gch)
     if (!*p)
       continue;
     *p++ = 0;
-    if (gethex(q, buf, gch->hashsz, 0) < gch->hashsz)
+    if (e->get(q, buf, gch->hashsz, 0) < gch->hashsz)
       continue;
     if (*p == '*')
       ff |= f_binary;
@@ -443,7 +530,8 @@ static int checkhash(const char *file, unsigned f, const gchash *gch)
   return (0);
 }
 
-static int dohash(const char *file, unsigned f, const gchash *gch)
+static int dohash(const char *file, unsigned f,
+                 const gchash *gch, const encops *e)
 {
   int rc = 0;
   octet *p = xmalloc(gch->hashsz);
@@ -452,7 +540,7 @@ static int dohash(const char *file, unsigned f, const gchash *gch)
     moan("couldn't read `%s': %s", file ? file : "<stdin>", strerror(errno));
     rc = EXIT_FAILURE;
   } else {
-    puthex(p, gch->hashsz, stdout);
+    e->put(p, gch->hashsz, stdout);
     if (file) {
       fputc(' ', stdout);
       fputc(f & f_binary ? '*' : ' ', stdout);
@@ -468,12 +556,14 @@ static int dohash(const char *file, unsigned f, const gchash *gch)
   return (rc);
 }
 
-static int dofile(const char *file, unsigned f, const gchash *gch)
+static int dofile(const char *file, unsigned f,
+                 const gchash *gch, const encops *e)
 {
-  return (f & f_check ? checkhash : dohash)(file, f, gch);
+  return (f & f_check ? checkhash : dohash)(file, f, gch, e);
 }
 
-static int hashfiles(const char *file, unsigned f, const gchash *gch)
+static int hashfiles(const char *file, unsigned f,
+                    const gchash *gch, const encops *e)
 {
   FILE *fp;
   dstr d = DSTR_INIT;
@@ -491,16 +581,17 @@ static int hashfiles(const char *file, unsigned f, const gchash *gch)
     DRESET(&d);
     if (getstring(fp, 0, &d, f & f_raw))
       break;
-    if ((rrc = dofile(d.buf, f, gch)) != 0)
+    if ((rrc = dofile(d.buf, f, gch, e)) != 0)
       rc = rrc;
   }
 
   return (rc);
 }
 
-static int hashsum(const char *file, unsigned f, const gchash *gch)
+static int hashsum(const char *file, unsigned f,
+                  const gchash *gch, const encops *e)
 {
-  return (f & f_files ? hashfiles : dofile)(file, f, gch);
+  return (f & f_files ? hashfiles : dofile)(file, f, gch, e);
 }
 
 /*----- Main driver -------------------------------------------------------*/
@@ -547,6 +638,7 @@ int main(int argc, char *argv[])
 {
   unsigned f = 0;
   const gchash *gch = 0;
+  const encops *e = &enctab[0];
   int rc;
 
   /* --- Initialization --- */
@@ -578,6 +670,7 @@ int main(int argc, char *argv[])
 
       { "algorithm",   OPTF_ARGREQ,    0,      'a' },
       { "hash",                OPTF_ARGREQ,    0,      'a' },
+      { "encoding",    OPTF_ARGREQ,    0,      'E' },
       { "list",                0,              0,      'l' },
 
       { "files",       0,              0,      'f' },
@@ -591,7 +684,7 @@ int main(int argc, char *argv[])
 
       { 0,             0,              0,      0 }
     };
-    int i = mdwopt(argc, argv, "hVu a:l f0 ecbv", opts, 0, 0, 0);
+    int i = mdwopt(argc, argv, "hVu a:E:l f0 ecbv", opts, 0, 0, 0);
     if (i < 0)
       break;
 
@@ -620,6 +713,11 @@ int main(int argc, char *argv[])
        fputc('\n', stdout);
        exit(0);
       } break;
+      case 'E':
+       if ((e = getenc(optarg)) == 0)
+         die(EXIT_FAILURE, "unknown encoding `%s'", optarg);
+       f |= f_oddenc;
+       break;
       case 'f':
        f |= f_files;
        break;
@@ -654,10 +752,9 @@ int main(int argc, char *argv[])
   /* --- Generate output --- */
 
   if (!(f & f_check)) {
-    if (f & f_oddhash)
-      printf("#hash %s\n", gch->name);
-    if (f & f_escape)
-      fputs("#escape\n", stdout);
+    if (f & f_oddhash) printf("#hash %s\n", gch->name);
+    if (f & f_oddenc) printf("#encoding %s\n", e->name);
+    if (f & f_escape) fputs("#escape\n", stdout);
   }
   
   if (argc) {
@@ -665,11 +762,11 @@ int main(int argc, char *argv[])
     int rrc;
     rc = 0;
     for (i = 0; i < argc; i++) {
-      if ((rrc = hashsum(argv[i], f, gch)) != 0)
+      if ((rrc = hashsum(argv[i], f, gch, e)) != 0)
        rc = rrc;
     }
   } else
-    rc = hashsum(0, f, gch);
+    rc = hashsum(0, f, gch, e);
 
   return (rc);
 }