fargo 0.1.1 → 0.2.0

data/ext/fargo/tiger.c

@@ -0,0 +1,245 @@
+/* (PD) 2001 The Bitzi Corporation
+ * Please see file COPYING or http://bitzi.com/publicdomain
+ * for more info.
+ *
+ * Created and released into the public domain by Eli Biham
+ *
+ * $Id: tiger.c,v 1.2 2006/11/16 11:21:20 chugunov Exp $
+ */
+#include "tiger.h"
+
+#ifdef _WIN32
+#undef WORDS_BIGENDIAN
+#else
+#endif
+
+#define _ULL(x) x##ull
+
+#ifdef WORDS_BIGENDIAN
+#   define USE_BIG_ENDIAN 1
+#else
+#   define USE_BIG_ENDIAN 0
+#endif
+
+/* The following macro denotes that an optimization    */
+/* for Alpha is required. It is used only for          */
+/* optimization of time. Otherwise it does nothing.    */
+#ifdef __alpha
+#define OPTIMIZE_FOR_ALPHA
+#endif
+
+/* NOTE that this code is NOT FULLY OPTIMIZED for any  */
+/* machine. Assembly code might be much faster on some */
+/* machines, especially if the code is compiled with   */
+/* gcc.                                                */
+
+/* The number of passes of the hash function.          */
+/* Three passes are recommended.                       */
+/* Use four passes when you need extra security.       */
+/* Must be at least three.                             */
+#define PASSES 3
+
+extern word64 table[4*256];
+
+#define t1 (table)
+#define t2 (table+256)
+#define t3 (table+256*2)
+#define t4 (table+256*3)
+
+#define save_abc \
+      aa = a; \
+      bb = b; \
+      cc = c;
+
+#ifdef OPTIMIZE_FOR_ALPHA
+/* This is the official definition of round */
+#define round(a,b,c,x,mul) \
+      c ^= x; \
+      a -= t1[((c)>>(0*8))&0xFF] ^ t2[((c)>>(2*8))&0xFF] ^ \
+     t3[((c)>>(4*8))&0xFF] ^ t4[((c)>>(6*8))&0xFF] ; \
+      b += t4[((c)>>(1*8))&0xFF] ^ t3[((c)>>(3*8))&0xFF] ^ \
+     t2[((c)>>(5*8))&0xFF] ^ t1[((c)>>(7*8))&0xFF] ; \
+      b *= mul;
+#else
+/* This code works faster when compiled on 32-bit machines */
+/* (but works slower on Alpha) */
+#define round(a,b,c,x,mul) \
+      c ^= x; \
+      a -= t1[(byte)(c)] ^ \
+           t2[(byte)(((word32)(c))>>(2*8))] ^ \
+     t3[(byte)((c)>>(4*8))] ^ \
+           t4[(byte)(((word32)((c)>>(4*8)))>>(2*8))] ; \
+      b += t4[(byte)(((word32)(c))>>(1*8))] ^ \
+           t3[(byte)(((word32)(c))>>(3*8))] ^ \
+     t2[(byte)(((word32)((c)>>(4*8)))>>(1*8))] ^ \
+           t1[(byte)(((word32)((c)>>(4*8)))>>(3*8))]; \
+      b *= mul;
+#endif
+
+#define pass(a,b,c,mul) \
+      round(a,b,c,x0,mul) \
+      round(b,c,a,x1,mul) \
+      round(c,a,b,x2,mul) \
+      round(a,b,c,x3,mul) \
+      round(b,c,a,x4,mul) \
+      round(c,a,b,x5,mul) \
+      round(a,b,c,x6,mul) \
+      round(b,c,a,x7,mul)
+
+#define key_schedule \
+      x0 -= x7 ^ _ULL(0xA5A5A5A5A5A5A5A5); \
+      x1 ^= x0; \
+      x2 += x1; \
+      x3 -= x2 ^ ((~x1)<<19); \
+      x4 ^= x3; \
+      x5 += x4; \
+      x6 -= x5 ^ ((~x4)>>23); \
+      x7 ^= x6; \
+      x0 += x7; \
+      x1 -= x0 ^ ((~x7)<<19); \
+      x2 ^= x1; \
+      x3 += x2; \
+      x4 -= x3 ^ ((~x2)>>23); \
+      x5 ^= x4; \
+      x6 += x5; \
+      x7 -= x6 ^ _ULL(0x0123456789ABCDEF);
+
+#define feedforward \
+      a ^= aa; \
+      b -= bb; \
+      c += cc;
+
+#ifdef OPTIMIZE_FOR_ALPHA
+/* The loop is unrolled: works better on Alpha */
+#define compress \
+      save_abc \
+      pass(a,b,c,5) \
+      key_schedule \
+      pass(c,a,b,7) \
+      key_schedule \
+      pass(b,c,a,9) \
+      for(pass_no=3; pass_no<PASSES; pass_no++) { \
+        key_schedule \
+  pass(a,b,c,9) \
+  tmpa=a; a=c; c=b; b=tmpa;} \
+      feedforward
+#else
+/* loop: works better on PC and Sun (smaller cache?) */
+#define compress \
+      save_abc \
+      for(pass_no=0; pass_no<PASSES; pass_no++) { \
+        if(pass_no != 0) {key_schedule} \
+  pass(a,b,c,(pass_no==0?5:pass_no==1?7:9)); \
+  tmpa=a; a=c; c=b; b=tmpa;} \
+      feedforward
+#endif
+
+/*
+#define tiger_compress_macro(str, state) \
+{ \
+  register word64 a, b, c, tmpa; \
+  word64 aa, bb, cc; \
+  register word64 x0, x1, x2, x3, x4, x5, x6, x7; \
+  register word32 i; \
+  int pass_no; \
+\
+  a = state[0]; \
+  b = state[1]; \
+  c = state[2]; \
+\
+  x0=str[0]; x1=str[1]; x2=str[2]; x3=str[3]; \
+  x4=str[4]; x5=str[5]; x6=str[6]; x7=str[7]; \
+\
+  compress; \
+\
+  state[0] = a; \
+  state[1] = b; \
+  state[2] = c; \
+}
+*/
+
+#define tiger_compress_macro(str, state) \
+{ \
+  register word64 a, b, c, tmpa; \
+  word64 aa, bb, cc; \
+  register word64 x0, x1, x2, x3, x4, x5, x6, x7; \
+  int pass_no; \
+\
+  a = state[0]; \
+  b = state[1]; \
+  c = state[2]; \
+\
+  x0=str[0]; x1=str[1]; x2=str[2]; x3=str[3]; \
+  x4=str[4]; x5=str[5]; x6=str[6]; x7=str[7]; \
+\
+  compress; \
+\
+  state[0] = a; \
+  state[1] = b; \
+  state[2] = c; \
+}
+
+/* The compress function is a function. Requires smaller cache?    */
+void tiger_compress(word64 *str, word64 state[3])
+{
+  tiger_compress_macro(((word64*)str), ((word64*)state));
+}
+
+#ifdef OPTIMIZE_FOR_ALPHA
+/* The compress function is inlined: works better on Alpha.        */
+/* Still leaves the function above in the code, in case some other */
+/* module calls it directly.                                       */
+#define tiger_compress(str, state) \
+  tiger_compress_macro(((word64*)str), ((word64*)state))
+#endif
+
+void tiger(word64 *str, word64 length, word64 res[3])
+{
+  register word64 i, j;
+  unsigned char temp[64];
+
+  res[0]=_ULL(0x0123456789ABCDEF);
+  res[1]=_ULL(0xFEDCBA9876543210);
+  res[2]=_ULL(0xF096A5B4C3B2E187);
+
+  for(i=length; i>=64; i-=64)
+    {
+#if USE_BIG_ENDIAN
+      for(j=0; j<64; j++)
+  temp[j^7] = ((byte*)str)[j];
+      tiger_compress(((word64*)temp), res);
+#else
+      tiger_compress(str, res);
+#endif
+      str += 8;
+    }
+
+#if USE_BIG_ENDIAN
+  for(j=0; j<i; j++)
+    temp[j^7] = ((byte*)str)[j];
+
+  temp[j^7] = 0x01;
+  j++;
+  for(; j&7; j++)
+    temp[j^7] = 0;
+#else
+  for(j=0; j<i; j++)
+    temp[j] = ((byte*)str)[j];
+
+  temp[j++] = 0x01;
+  for(; j&7; j++)
+    temp[j] = 0;
+#endif
+  if(j>56)
+    {
+      for(; j<64; j++)
+  temp[j] = 0;
+      tiger_compress(((word64*)temp), res);
+      j=0;
+    }
+
+  for(; j<56; j++)
+    temp[j] = 0;
+  ((word64*)(&(temp[56])))[0] = ((word64)length)<<3;
+  tiger_compress(((word64*)temp), res);
+}

data/ext/fargo/tiger.h

@@ -0,0 +1,41 @@
+/* (PD) 2001 The Bitzi Corporation
+ * Please see file COPYING or http://bitzi.com/publicdomain
+ * for more info.
+ *
+ * $Id: tiger.h,v 1.1 2006/11/16 11:21:20 chugunov Exp $
+ */
+#ifndef TIGER_H
+#define TIGER_H
+
+#ifdef _WIN32
+
+#if defined (_INTEGRAL_MAX_BITS) && (_INTEGRAL_MAX_BITS >= 64)
+  typedef unsigned __int64 word64;
+#else
+  #error __int64 type not supported
+#endif
+typedef unsigned long int tword;
+
+#else
+#include <sys/types.h>
+typedef u_int64_t  word64;
+typedef u_int32_t  word32;
+typedef u_int16_t  word16;
+#endif
+
+#ifndef __BYTE__
+#define __BYTE__
+typedef unsigned char  byte;
+#endif
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+void tiger(word64 *str, word64 length, word64 *res);
+
+#if defined(__cplusplus)
+}
+#endif
+
+#endif

data/ext/fargo/tigertree.c

@@ -0,0 +1,184 @@
+/* (PD) 2001 The Bitzi Corporation
+ * Copyright (C) 2006 Alexey Illarionov <littlesavage@rambler.ru>
+ *
+ * Please see file COPYING or http://bitzi.com/publicdomain
+ * for more info.
+ *
+ * tigertree.c - Implementation of the TigerTree algorithm
+ *
+ * NOTE: The TigerTree hash value cannot be calculated using a
+ * constant amount of memory; rather, the memory required grows
+ * with the size of input. (Roughly, one more interim value must
+ * be remembered for each doubling of the input size.) The
+ * default TT_CONTEXT struct size reserves enough memory for
+ * input up to 2^64 in length
+ *
+ * Requires the tiger() function as defined in the reference
+ * implementation provided by the creators of the Tiger
+ * algorithm. See
+ *
+ *    http://www.cs.technion.ac.il/~biham/Reports/Tiger/
+ *
+ */
+
+#include <assert.h>
+#include <string.h>
+#include "tigertree.h"
+
+//#define _TRACE
+#if defined(_TRACE)
+#include <stdio.h>
+#define TRACE(x)    printf x; fflush(stdout);
+#else
+#define TRACE(x)
+#endif
+
+#ifdef _WIN32
+#undef WORDS_BIGENDIAN
+#else
+#endif
+
+#ifdef WORDS_BIGENDIAN
+#   define USE_BIG_ENDIAN 1
+void tt_endian(byte *s);
+#else
+#   define USE_BIG_ENDIAN 0
+#endif
+
+/* Initialize the tigertree context */
+void tt_init(TT_CONTEXT *ctx, unsigned char *tthl, unsigned depth)
+{
+  ctx->count = 0;
+  ctx->node[0] = '\1'; // flag for inner node calculation -- never changed
+  ctx->index = 0;   // partial block pointer/block length
+  ctx->top = ctx->nodes;
+  ctx->tthl = tthl;
+  ctx->depth = depth;
+}
+
+static void tt_compose(TT_CONTEXT *ctx) {
+  byte *node = ctx->top - NODESIZE;
+  memmove((ctx->node)+1,node,NODESIZE); // copy to scratch area
+  tiger((word64*)(ctx->node),(word64)(NODESIZE+1),(word64*)(ctx->top)); // combine two nodes
+#if USE_BIG_ENDIAN
+  tt_endian((byte *)ctx->top);
+#endif
+  memmove(node,ctx->top,TIGERSIZE);           // move up result
+  ctx->top -= TIGERSIZE;                      // update top ptr
+}
+
+void tt_block(TT_CONTEXT *ctx)
+{
+    word64 b;
+    unsigned depth;
+
+    tiger((word64*)ctx->leaf,(word64)ctx->index+1,(word64*)ctx->top);
+#if USE_BIG_ENDIAN
+    tt_endian((byte *)ctx->top);
+#endif
+    ctx->top += TIGERSIZE;
+    ++ctx->count;
+    b = ctx->count;
+    depth = 0;
+    while(b == ((b >> 1)<<1)) { // while evenly divisible by 2...
+        /*
+        if (depth == ctx->depth) {
+            TRACE(("depth = %d, b == %lld\n", depth, b));
+            memmove(ctx->tthl, ctx->top - 2*TIGERSIZE, 2*TIGERSIZE);
+            ctx->tthl += 2*TIGERSIZE;
+        }
+        */
+        tt_compose(ctx);
+        b = b >> 1;
+        depth++;
+    }
+}
+
+// no need to call this directly; tt_digest calls it for you
+static void tt_final(TT_CONTEXT *ctx)
+{
+  // do last partial block, unless index is 1 (empty leaf)
+  // AND we're past the first block
+  if((ctx->index>0)||(ctx->top==ctx->nodes))
+    tt_block(ctx);
+}
+
+void tt_digest(TT_CONTEXT *ctx, byte *s)
+{
+    unsigned dth_top0 = 0, dth_top1 = 0;
+    word64 tmp, cnt;
+    tt_final(ctx);
+
+    /*
+    dth_top0 = 0;
+    cnt = ctx->count;
+    tmp = cnt;
+    while(tmp == ((tmp >> 1)<<1)) {
+        dth_top0++;
+        tmp >>= 1;
+    }
+    cnt -= ((word64)1 << dth_top0);
+
+    TRACE(("ctx->top-TIGERSIZE - ctx->nodes == %d\n", ctx->top-TIGERSIZE - ctx->nodes));
+    */
+
+    while( (ctx->top-TIGERSIZE) > ctx->nodes) {
+        /*
+        assert(cnt > 0);
+
+        dth_top1 = 0;
+        tmp = cnt;
+        while (tmp == ((tmp >> 1)<<1)) {
+            dth_top1++;
+            tmp >>= 1;
+        }
+        cnt -= ((word64)1 << dth_top1);
+
+        if ((ctx->depth <= dth_top1) && (ctx->depth >= dth_top0)) {
+            if ( dth_top1 == ctx->depth) {
+                TRACE(("depth = %d, dth_top0 == %d, dth_top1 == %d\n", ctx->depth, dth_top0, dth_top1));
+                memmove(ctx->tthl, ctx->top - 2*TIGERSIZE, 2*TIGERSIZE);
+                ctx->tthl += 2*TIGERSIZE;
+            } else {
+                TRACE(("depth = %d, dth_top0 == %d, dth_top1 == %d\n", ctx->depth, dth_top0, dth_top1));
+                memmove(ctx->tthl, ctx->top - TIGERSIZE, TIGERSIZE);
+                ctx->tthl += TIGERSIZE;
+            }
+        }
+        */
+        tt_compose(ctx);
+        dth_top0 = dth_top1 + 1;
+    }
+
+    memmove(s,ctx->nodes, TIGERSIZE);
+}
+
+#if USE_BIG_ENDIAN
+void tt_endian(byte *s)
+{
+  word64 *i;
+  byte   *b, btemp;
+  word16 *w, wtemp;
+
+  for(w = (word16 *)s; w < ((word16 *)s) + 12; w++)
+  {
+      b = (byte *)w;
+      btemp = *b;
+      *b = *(b + 1);
+      *(b + 1) = btemp;
+  }
+
+  for(i = (word64 *)s; i < ((word64 *)s) + 3; i++)
+  {
+      w = (word16 *)i;
+
+      wtemp = *w;
+      *w = *(w + 3);
+      *(w + 3) = wtemp;
+
+      wtemp = *(w + 1);
+      *(w + 1) = *(w + 2);
+      *(w + 2) = wtemp;
+  }
+}
+#endif

data/ext/fargo/tigertree.h

@@ -0,0 +1,48 @@
+/* (PD) 2001 The Bitzi Corporation
+ * Copyright (C) 2006 Alexey Illarionov <littlesavage@rambler.ru>
+ * Please see file COPYING or http://bitzi.com/publicdomain
+ * for more info.
+ *
+ */
+#include "tiger.h"
+
+/* tiger hash result size, in bytes */
+#define TIGERSIZE 24
+
+/* size of each block independently tiger-hashed, not counting leaf 0x00 prefix */
+#define BLOCKSIZE 1024
+
+/* size of input to each non-leaf hash-tree node, not counting node 0x01 prefix */
+#define NODESIZE (TIGERSIZE*2)
+
+/* default size of interim values stack, in TIGERSIZE
+ * blocks. If this overflows (as it will for input
+ * longer than 2^64 in size), havoc may ensue. */
+#define STACKSIZE TIGERSIZE*56
+
+typedef struct tt_context {
+  word64 count;                   /* total blocks processed */
+#if 0
+  unsigned char leaf[1+BLOCKSIZE]; /* leaf in progress */
+  unsigned char *block;            /* leaf data */
+#endif
+  unsigned char  *leaf;      /* leaf in progress */
+  unsigned char node[1+NODESIZE]; /* node scratch space */
+  int index;                      /* index into block */
+  unsigned char *top;             /* top (next empty) stack slot */
+  unsigned char *tthl;      /* index into buf for tth leaves */
+  unsigned  depth;      /* num of generations in tree to discard */
+  unsigned char nodes[STACKSIZE]; /* stack of interim node values */
+} TT_CONTEXT;
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+void tt_init(TT_CONTEXT *ctx, unsigned char *tthl, unsigned depth);
+//void tt_update(TT_CONTEXT *ctx, unsigned char *buffer, word32 len);
+void tt_block(TT_CONTEXT *ctx);
+void tt_digest(TT_CONTEXT *ctx, unsigned char *hash);
+void tt_copy(TT_CONTEXT *dest, TT_CONTEXT *src);
+#if defined(__cplusplus)
+}
+#endif

data/ext/fargo/tth.c

@@ -0,0 +1,100 @@
+/*
+ * tth.c
+ * This file is part of microdc
+ *
+ * Copyright (C) 2006 Alexey Illarionov <littlesavage@rambler.ru>
+ *
+ * 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 Library 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "tigertree.h"
+#include "base32.h"
+
+//#define _TRACE
+#if defined(_TRACE)
+#define TRACE(x)    printf x; fflush(stdout);
+#else
+#define TRACE(x)
+#endif
+
+const size_t default_block_level    = 6;
+const int    max_block_count        = (1 << 6);
+
+#define MAXHASHES ( ((word64)1) << 9  )
+/* blocksize for one leaf is 65536 bytes */
+#define STARTDEPTH 6
+
+int calc_block_level(word64 filesize, int max_block_count)
+{
+    int level;
+    for (level = default_block_level; (((word64)1) << (level+10)) * max_block_count < filesize; level++);
+    return level;
+}
+
+char* tth(const char* filename, char **tthl, size_t *tthl_len)
+{
+    char *tth;
+    size_t numbytes;
+    unsigned char root[24];
+    unsigned char *cur;
+    TT_CONTEXT tt;
+    unsigned char buf[1 + 512 * BLOCKSIZE];
+    struct stat sb;
+    unsigned level;
+    size_t leaf_blocksize;
+
+    int fd = open(filename, O_RDONLY);
+    if ((fd == -1) || ( fstat(fd, &sb) == -1)) {
+        return NULL;
+    }
+
+    level = calc_block_level(sb.st_size, max_block_count);
+    leaf_blocksize = 1 << (level+10);
+
+    *tthl_len = 0;
+    *tthl = NULL;
+
+    tt_init(&tt, *tthl, level);
+    tt.leaf = buf;
+    buf[0] = '\0';
+
+    while ( (numbytes = read(fd, &buf[1], sizeof(buf) - 1) ) > 0) {
+        tt.index = BLOCKSIZE;
+        for (cur = &buf[1]; cur + BLOCKSIZE <= &buf[numbytes + 1]; cur += BLOCKSIZE) {
+            tt.leaf = cur - 1;
+            tt.leaf[0] = '\0';
+            tt_block(&tt);
+        }
+        tt.index = numbytes - (cur - &buf[1]);
+        tt.leaf = cur - 1;
+        tt.leaf[0] = '\0';
+    }
+
+    close(fd);
+
+    tt_digest(&tt, root);
+
+    tth = base32_encode(root, sizeof(root));
+
+    return tth;
+}

data/ext/fargo/tth.h

@@ -0,0 +1,18 @@
+#ifndef __TTH_H
+#define __TTH_H
+
+#include "tiger.h"
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+// user must call free() funtion on pointer returned from these functions
+
+char* tth(const char* filename, char **tthl, size_t *tthl_len);
+
+#if defined(__cplusplus)
+}
+#endif
+
+#endif // ifndef __TTH_H