transmission 0.1.0

data/ext/ratecontrol.c

@@ -0,0 +1,170 @@
+/******************************************************************************
+ * $Id: ratecontrol.c 261 2006-05-29 21:27:31Z titer $
+ *
+ * Copyright (c) 2006 Transmission authors and contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ *****************************************************************************/
+
+#include "transmission.h"
+
+#define MAX_HISTORY 30
+
+typedef struct tr_transfer_s tr_transfer_t;
+struct tr_ratecontrol_s
+{
+    tr_lock_t       lock;
+    int             limit;
+    tr_transfer_t * first;
+    tr_transfer_t * last;
+};
+struct tr_transfer_s
+{
+    uint64_t        date;
+    int             size;
+    tr_transfer_t * next;
+    tr_transfer_t * prev;
+};
+
+/***********************************************************************
+ * rateForInterval
+ ***********************************************************************
+ * Returns the transfer rate on the last 'interval' milliseconds
+ **********************************************************************/
+static inline float rateForInterval( tr_ratecontrol_t * r, int interval )
+{
+    tr_transfer_t * t;
+    uint64_t        start = tr_date() - interval;
+    int             total = 0;
+
+    for( t = r->first; t && t->date > start; t = t->next )
+    {
+        total += t->size;
+    }
+
+    return ( 1000.0 / 1024.0 ) * total / interval;
+}
+
+static inline void cleanOldTransfers( tr_ratecontrol_t * r )
+{
+    tr_transfer_t * t, * prev;
+    uint64_t        old = tr_date() - MAX_HISTORY * 1000;
+
+    for( t = r->last; t && t->date < old; )
+    {
+        prev = t->prev;
+        if( prev )
+            prev->next = NULL;
+        else
+            r->first = NULL;
+        free( t );
+        t       = prev;
+        r->last = prev;
+    }
+}
+
+tr_ratecontrol_t * tr_rcInit()
+{
+    tr_ratecontrol_t * r;
+
+    r        = calloc( sizeof( tr_ratecontrol_t ), 1 );
+    r->limit = -1;
+    tr_lockInit( &r->lock );
+
+    return r;
+}
+
+void tr_rcSetLimit( tr_ratecontrol_t * r, int limit )
+{
+    tr_lockLock( &r->lock );
+    r->limit = limit;
+    tr_lockUnlock( &r->lock );
+}
+
+int tr_rcCanTransfer( tr_ratecontrol_t * r )
+{
+    int ret;
+
+    tr_lockLock( &r->lock );
+    ret = ( r->limit < 0 ) || ( rateForInterval( r, 1000 ) < r->limit );
+    tr_lockUnlock( &r->lock );
+
+    return ret;
+}
+
+void tr_rcTransferred( tr_ratecontrol_t * r, int size )
+{
+    tr_transfer_t * t;
+
+    if( size < 100 )
+    {
+        return;
+    }
+    
+    tr_lockLock( &r->lock );
+    t = malloc( sizeof( tr_transfer_t ) );
+
+    if( r->first )
+        r->first->prev = t;
+    if( !r->last )
+        r->last = t;
+    t->next  = r->first;
+    t->prev  = NULL;
+    r->first = t;
+
+    t->date  = tr_date();
+    t->size  = size;
+
+    cleanOldTransfers( r );
+    tr_lockUnlock( &r->lock );
+}
+
+float tr_rcRate( tr_ratecontrol_t * r )
+{
+    float ret;
+
+    tr_lockLock( &r->lock );
+    ret = rateForInterval( r, MAX_HISTORY * 1000 );
+    tr_lockUnlock( &r->lock );
+
+    return ret;
+}
+
+void tr_rcReset( tr_ratecontrol_t * r )
+{
+    tr_transfer_t * t, * next;
+
+    tr_lockLock( &r->lock );
+    for( t = r->first; t; )
+    {
+        next = t->next;
+        free( t );
+        t = next;
+    }
+    r->first = NULL;
+    r->last  = NULL;
+    tr_lockUnlock( &r->lock );
+}
+
+void tr_rcClose( tr_ratecontrol_t * r )
+{
+    tr_rcReset( r );
+    tr_lockClose( &r->lock );
+    free( r );
+}

data/ext/ratecontrol.h

@@ -0,0 +1,33 @@
+/******************************************************************************
+ * $Id: ratecontrol.h 261 2006-05-29 21:27:31Z titer $
+ *
+ * Copyright (c) 2006 Transmission authors and contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ *****************************************************************************/
+
+typedef struct tr_ratecontrol_s tr_ratecontrol_t;
+
+tr_ratecontrol_t * tr_rcInit();
+void               tr_rcSetLimit( tr_ratecontrol_t *, int );
+int                tr_rcCanTransfer( tr_ratecontrol_t * );
+void               tr_rcTransferred( tr_ratecontrol_t *, int );
+float              tr_rcRate( tr_ratecontrol_t * );
+void               tr_rcReset( tr_ratecontrol_t * );
+void               tr_rcClose( tr_ratecontrol_t * );

data/ext/sha1.c

@@ -0,0 +1,235 @@
+/*
+ sha1.c: Implementation of SHA-1 Secure Hash Algorithm-1
+
+ Based upon: NIST FIPS180-1 Secure Hash Algorithm-1
+   http://www.itl.nist.gov/fipspubs/fip180-1.htm
+
+ Non-official Japanese Translation by HIRATA Yasuyuki:
+   http://yasu.asuka.net/translations/SHA-1.html
+
+ Copyright (C) 2002 vi@nwr.jp. All rights reserved.
+
+ This software is provided 'as-is', without any express or implied
+ warranty. In no event will the authors be held liable for any damages
+ arising from the use of this software.
+
+ Permission is granted to anyone to use this software for any purpose,
+ including commercial applications, and to alter it and redistribute it
+ freely, subject to the following restrictions:
+
+ 1. The origin of this software must not be misrepresented; you must not
+    claim that you wrote the original software. If you use this software
+    in a product, an acknowledgement in the product documentation would be
+    appreciated but is not required.
+ 2. Altered source versions must be plainly marked as such, and must not be
+    misrepresented as beging the original software.
+ 3. This notice may not be removed or altered from any source distribution.
+
+ Note:
+   The copyright notice above is copied from md5.h by L. Peter Deutsch
+   <ghost@aladdin.com>. Thank him since I'm not a good speaker of English. :)
+ */
+#include <string.h>
+#include "sha1.h"
+
+#define	INLINE	inline
+/*
+ * Packing bytes to a word
+ *
+ * Should not assume p is aligned to word boundary
+ */
+static INLINE sha1_word_t packup(sha1_byte_t *p)
+{
+  /* Portable, but slow */
+  return p[0] << 24 | p[1] << 16 | p[2] << 8 | p[3] << 0;
+}
+
+/*
+ * Unpacking a word to bytes
+ *
+ * Should not assume p is aligned to word boundary
+ */
+static void unpackup(sha1_byte_t *p, sha1_word_t q)
+{
+  p[0] = (q >> 24) & 0xff;
+  p[1] = (q >> 16) & 0xff;
+  p[2] = (q >>  8) & 0xff;
+  p[3] = (q >>  0) & 0xff;
+}
+
+/*
+ * Processing a block
+ */
+static inline void sha1_update_now(sha1_state_s *pms, sha1_byte_t *bp)
+{
+  sha1_word_t	tmp, a, b, c, d, e, w[16+16];
+  int	i, s;
+
+  /* pack 64 bytes into 16 words */
+  for(i = 0; i < 16; i++) {
+    w[i] = packup(bp + i * sizeof(sha1_word_t));
+  }
+  memcpy(w + 16, w + 0, sizeof(sha1_word_t) * 16);
+
+  a = pms->sha1_h[0], b = pms->sha1_h[1], c = pms->sha1_h[2], d = pms->sha1_h[3], e = pms->sha1_h[4];
+
+#define	rot(x,n) (((x) << n) | ((x) >> (32-n)))
+#define	f0(b, c, d)	((b&c)|(~b&d))
+#define	f1(b, c, d)	(b^c^d)
+#define	f2(b, c, d)	((b&c)|(b&d)|(c&d))
+#define	f3(b, c, d)	(b^c^d)
+#define k0		0x5a827999
+#define	k1		0x6ed9eba1
+#define	k2		0x8f1bbcdc
+#define	k3		0xca62c1d6
+
+  /* t=0-15 */
+  s = 0;
+  for(i = 0; i < 16; i++) {
+    tmp = rot(a, 5) + f0(b, c, d) + e + w[s] + k0;
+    e = d; d = c; c = rot(b, 30); b = a; a = tmp;
+    s = (s + 1) % 16;
+  }
+
+  /* t=16-19 */
+  for(i = 16; i < 20; i++) {
+    w[s] = rot(w[s+13] ^ w[s+8] ^ w[s+2] ^ w[s], 1);
+    w[s+16] = w[s];
+    tmp = rot(a, 5) + f0(b, c, d) + e + w[s] + k0;
+    e = d; d = c; c = rot(b, 30); b = a; a = tmp;
+    s = (s + 1) % 16;
+  }
+
+  /* t=20-39 */
+  for(i = 0; i < 20; i++) {
+    w[s] = rot(w[s+13] ^ w[s+8] ^ w[s+2] ^ w[s], 1);
+    w[s+16] = w[s];
+    tmp = rot(a, 5) + f1(b, c, d) + e + w[s] + k1;
+    e = d; d = c; c = rot(b, 30); b = a; a = tmp;
+    s = (s + 1) % 16;
+  }
+
+  /* t=40-59 */
+  for(i = 0; i < 20; i++) {
+    w[s] = rot(w[s+13] ^ w[s+8] ^ w[s+2] ^ w[s], 1);
+    w[s+16] = w[s];
+    tmp = rot(a, 5) + f2(b, c, d) + e + w[s] + k2;
+    e = d; d = c; c = rot(b, 30); b = a; a = tmp;
+    s = (s + 1) % 16;
+  }
+
+  /* t=60-79 */
+  for(i = 0; i < 20; i++) {
+    w[s] = rot(w[s+13] ^ w[s+8] ^ w[s+2] ^ w[s], 1);
+    w[s+16] = w[s];
+    tmp = rot(a, 5) + f3(b, c, d) + e + w[s] + k3;
+    e = d; d = c; c = rot(b, 30); b = a; a = tmp;
+    s = (s + 1) % 16;
+  }
+
+  pms->sha1_h[0] += a, pms->sha1_h[1] += b, pms->sha1_h[2] += c, pms->sha1_h[3] += d, pms->sha1_h[4] += e;
+}
+
+/*
+ * Increment sha1_size1, sha1_size2 field of sha1_state_s
+ */
+static INLINE void incr(sha1_state_s *pms, int v)
+{
+  sha1_word_t	q;
+
+  q = pms->sha1_size1 + v * BITS;
+  if(q < pms->sha1_size1) {
+    pms->sha1_size2++;
+  }
+  pms->sha1_size1 = q;
+}
+
+/*
+ * Initialize sha1_state_s as FIPS specifies
+ */
+void	sha1_init(sha1_state_s *pms)
+{
+  memset(pms, 0, sizeof(*pms));
+  pms->sha1_h[0] = 0x67452301;	/* Initialize H[0]-H[4] */
+  pms->sha1_h[1] = 0xEFCDAB89;
+  pms->sha1_h[2] = 0x98BADCFE;
+  pms->sha1_h[3] = 0x10325476;
+  pms->sha1_h[4] = 0xC3D2E1F0;
+}
+
+/*
+ * Fill block and update output when needed
+ */
+void	sha1_update(sha1_state_s *pms, sha1_byte_t *bufp, int length)
+{
+  /* Is the buffer partially filled? */
+  if(pms->sha1_count != 0) {
+    if(pms->sha1_count + length >= (signed) sizeof(pms->sha1_buf)) {	/* buffer is filled enough */
+      int fil = sizeof(pms->sha1_buf) - pms->sha1_count;		/* length to copy */
+
+      memcpy(pms->sha1_buf + pms->sha1_count, bufp, fil);
+      sha1_update_now(pms, pms->sha1_buf);
+      length -= fil;
+      bufp += fil;
+      pms->sha1_count = 0;
+      incr(pms, fil);
+    } else {
+      memcpy(pms->sha1_buf + pms->sha1_count, bufp, length);
+      pms->sha1_count += length;
+      incr(pms, length);
+      return;
+    }
+  }
+
+  /* Loop to update state */
+  for(;;) {
+    if(length < (signed) sizeof(pms->sha1_buf)) {		/* Short to fill up the buffer */
+      if(length) {
+        memcpy(pms->sha1_buf, bufp, length);
+      }
+      pms->sha1_count = length;
+      incr(pms, length);
+      break;
+    }
+    sha1_update_now(pms, bufp);
+    length -= sizeof(pms->sha1_buf);
+    bufp += sizeof(pms->sha1_buf);
+    incr(pms, sizeof(pms->sha1_buf));
+  }
+}
+
+void	sha1_finish(sha1_state_s *pms, sha1_byte_t output[SHA1_OUTPUT_SIZE])
+{
+  int i;
+  sha1_byte_t buf[1];
+
+  /* fill a bit */
+  buf[0] = 0x80;
+  sha1_update(pms, buf, 1);
+
+  /* Decrement sha1_size1, sha1_size2 */
+  if((pms->sha1_size1 -= BITS) == 0) {
+    pms->sha1_size2--;
+  }
+
+  /* fill zeros */
+  if(pms->sha1_count > (signed) (sizeof(pms->sha1_buf) - 2 * sizeof(sha1_word_t))) {
+    memset(pms->sha1_buf + pms->sha1_count, 0, sizeof(pms->sha1_buf) - pms->sha1_count);
+    sha1_update_now(pms, pms->sha1_buf);
+    pms->sha1_count = 0;
+  }
+  memset(pms->sha1_buf + pms->sha1_count, 0,
+    sizeof(pms->sha1_buf) - pms->sha1_count - sizeof(sha1_word_t) * 2);
+
+  /* fill last length */
+  unpackup(pms->sha1_buf + sizeof(pms->sha1_buf) - sizeof(sha1_word_t) * 2, pms->sha1_size2);
+  unpackup(pms->sha1_buf + sizeof(pms->sha1_buf) - sizeof(sha1_word_t) * 1, pms->sha1_size1);
+
+  /* final update */
+  sha1_update_now(pms, pms->sha1_buf);
+
+  /* move hash value to output byte array */
+  for(i = 0; i < (signed) (sizeof(pms->sha1_h)/sizeof(sha1_word_t)); i++) {
+    unpackup(output + i * sizeof(sha1_word_t), pms->sha1_h[i]);
+  }
+}

data/ext/sha1.h

@@ -0,0 +1,68 @@
+/*
+ sha1.h: Implementation of SHA-1 Secure Hash Algorithm-1
+
+ Based upon: NIST FIPS180-1 Secure Hash Algorithm-1
+   http://www.itl.nist.gov/fipspubs/fip180-1.htm
+
+ Non-official Japanese Translation by HIRATA Yasuyuki:
+   http://yasu.asuka.net/translations/SHA-1.html
+
+ Copyright (C) 2002 vi@nwr.jp. All rights reserved.
+
+ This software is provided 'as-is', without any express or implied
+ warranty. In no event will the authors be held liable for any damages
+ arising from the use of this software.
+
+ Permission is granted to anyone to use this software for any purpose,
+ including commercial applications, and to alter it and redistribute it
+ freely, subject to the following restrictions:
+
+ 1. The origin of this software must not be misrepresented; you must not
+    claim that you wrote the original software. If you use this software
+    in a product, an acknowledgement in the product documentation would be
+    appreciated but is not required.
+ 2. Altered source versions must be plainly marked as such, and must not be
+    misrepresented as beging the original software.
+ 3. This notice may not be removed or altered from any source distribution.
+
+ Note:
+   The copyright notice above is copied from md5.h by L. Petet Deutsch
+   <ghost@aladdin.com>. Thank him since I'm not a good speaker of English. :)
+ */
+#ifndef	SHA1_H
+#define	SHA1_H
+
+typedef	unsigned int	sha1_word_t;	/* 32bits unsigned integer */
+typedef unsigned char	sha1_byte_t;	/* 8bits unsigned integer */
+#define	BITS		8
+
+/* Define the state of SHA-1 algorithm */
+typedef struct {
+  sha1_byte_t	sha1_buf[64];	/* 512 bits */
+  int		sha1_count;	/* How many bytes are used */
+  sha1_word_t	sha1_size1;		/* Length counter Lower Word */
+  sha1_word_t	sha1_size2;		/* Length counter Upper Word */
+  sha1_word_t	sha1_h[5];		/* Hash output */
+} sha1_state_s;
+#define	SHA1_OUTPUT_SIZE	20	/* in bytes */
+
+/* External Functions */
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+/* Initialize SHA-1 algorithm */
+void	sha1_init(sha1_state_s *pms);
+
+/* Append a string to SHA-1 algorithm */
+void	sha1_update(sha1_state_s *pms, sha1_byte_t *input_buffer, int length);
+
+/* Finish the SHA-1 algorithm and return the hash */
+void	sha1_finish(sha1_state_s *pms, sha1_byte_t output[SHA1_OUTPUT_SIZE]);
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif